@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/run/ship/run-ship-stop-context.ts

@@ -0,0 +1,206 @@
+import { stripVTControlCharacters } from 'node:util'
+import { agent_role_profile } from '#scripts/agent/agent-role-profile'
+import { changed_paths } from '#scripts/git/changed-paths'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { z } from 'zod'
+import { run_ship_next } from './run-ship-next'
+import { run_ship_probe } from './run-ship-probe'
+
+// What a relaunched lane child needs in front of it to fix a stopped ship: the tail of the failed
+// stage's output — a red check, or the High/Medium findings a review stage reports — and the branch's
+// changed files. Without them the resumed session opened `josh ship --log` and `git diff` itself before
+// doing anything (joshuafolkken/kit#3923).
+//
+// **Both are bounded**, so a long gate log never becomes the whole prompt. The tail is kept because a
+// check reports its verdict last; the lines left out go to a file whose path and line range the prompt
+// names, so nothing is lost and the session reads only the range it needs.
+
+const EXCERPT_LINE_LIMIT = 40
+const EXCERPT_LINE_WIDTH = 240
+const CHANGED_PATH_LIMIT = 30
+const OUTPUT_PREFIX = 'josh-ship-stop-'
+const OUTPUT_SUFFIX = '.log'
+const KEY_SEPARATOR = '-'
+const LINE_BREAK = '\n'
+const CARRIAGE_RETURN = '\r'
+
+const omitted_schema = z
+	.object({ path: z.string().optional(), last_line: z.number().int() })
+	.strict()
+const stop_context_schema = z
+	.object({
+		excerpt: z.array(z.string()).readonly(),
+		omitted: omitted_schema.optional(),
+		changed: z.array(z.string()).readonly().optional(),
+		more_changed: z.number().int(),
+	})
+	.strict()
+
+type StopContext = z.infer<typeof stop_context_schema>
+type Omitted = z.infer<typeof omitted_schema>
+
+// A spinner redraws its line with a carriage return, so only the frame after the last one is what the
+// terminal showed; a CRLF line ends in one and keeps its whole text.
+function shown_frame(line: string): string {
+	return line.trimEnd().split(CARRIAGE_RETURN).at(-1) ?? ''
+}
+
+function output_lines(output: string): Array<string> {
+	return stripVTControlCharacters(output)
+		.trimEnd()
+		.split(LINE_BREAK)
+		.map((line) => agent_role_profile.printable(shown_frame(line)))
+}
+
+// The full output is kept beside the ship log, keyed the same way, so the prompt's line range points at
+// text that reads exactly as the excerpt was cut from.
+async function keep_full_output(issue: string, output: string): Promise<string | undefined> {
+	const repository = await run_ship_probe.repository_directory()
+
+	if (repository === undefined) return undefined
+
+	const target = stamp_file.stamp_path(
+		`${OUTPUT_PREFIX}${issue}${KEY_SEPARATOR}`,
+		repository,
+		OUTPUT_SUFFIX,
+	)
+
+	try {
+		return stamp_file.replace_text_stamp(target, output)
+	} catch {
+		return undefined
+	}
+}
+
+// A full output that could not be kept still reports the cut, with no path: the prompt then points at
+// the stopped report, which holds the same lines.
+async function omitted_range(issue: string, lines: ReadonlyArray<string>): Promise<Omitted> {
+	const path = await keep_full_output(issue, lines.join(LINE_BREAK))
+	const last_line = lines.length - EXCERPT_LINE_LIMIT
+
+	return path === undefined ? { last_line } : { path, last_line }
+}
+
+// A line is cut to a width, so one minified or wrapped line cannot spend the prompt's whole budget.
+function clipped(lines: ReadonlyArray<string>): Array<string> {
+	return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH))
+}
+
+async function excerpt_of(
+	issue: string,
+	output: string,
+): Promise<Pick<StopContext, 'excerpt' | 'omitted'>> {
+	const lines = output.trim() === '' ? [] : output_lines(output)
+
+	if (lines.length <= EXCERPT_LINE_LIMIT) return { excerpt: clipped(lines) }
+
+	return {
+		excerpt: clipped(lines.slice(-EXCERPT_LINE_LIMIT)),
+		omitted: await omitted_range(issue, lines),
+	}
+}
+
+// A git that cannot answer leaves the list out rather than costing the relaunch — never empty, which
+// would read as a branch with no changes.
+async function read_paths(): Promise<Array<string> | undefined> {
+	try {
+		return await changed_paths.read_changed_paths(false)
+	} catch {
+		return undefined
+	}
+}
+
+async function changed_of(): Promise<Pick<StopContext, 'changed' | 'more_changed'>> {
+	const paths = await read_paths()
+
+	if (paths === undefined) return { more_changed: 0 }
+
+	return {
+		changed: paths.slice(0, CHANGED_PATH_LIMIT),
+		more_changed: Math.max(0, paths.length - CHANGED_PATH_LIMIT),
+	}
+}
+
+async function build(issue: string, output: string): Promise<StopContext> {
+	return { ...(await excerpt_of(issue, output)), ...(await changed_of()) }
+}
+
+function has_excerpt(context: StopContext | undefined): boolean {
+	return context !== undefined && context.excerpt.length > 0
+}
+
+function excerpt_heading(issue: string, omitted: Omitted | undefined, shown: number): string {
+	if (omitted === undefined) return 'The failed stage output:'
+
+	const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue}\`)`
+	const range = `lines 1-${String(omitted.last_line)} are in ${source}`
+
+	return `The failed stage output (its last ${String(shown)} lines; ${range}):`
+}
+
+// The head lines a budget leaves out join the range the heading names; the file, when one was kept,
+// still holds every line.
+function with_dropped(omitted: Omitted | undefined, dropped: number): Omitted | undefined {
+	if (dropped === 0) return omitted
+
+	return { ...omitted, last_line: (omitted?.last_line ?? 0) + dropped }
+}
+
+function excerpt_block(
+	issue: string,
+	context: StopContext,
+	changed: string,
+	dropped: number,
+): string {
+	const shown = context.excerpt.slice(dropped)
+	const heading = excerpt_heading(issue, with_dropped(context.omitted, dropped), shown.length)
+
+	return [heading, ...shown, changed].join(LINE_BREAK)
+}
+
+function changed_text(context: StopContext): string {
+	if (context.changed === undefined) return 'The changed files could not be read from git.'
+
+	if (context.changed.length === 0) return 'No files changed against the default branch.'
+
+	const more = context.more_changed > 0 ? ` (and ${String(context.more_changed)} more)` : ''
+
+	return `Changed files on the branch: ${context.changed.join(', ')}${more}.`
+}
+
+// The block the ship-stop prompt carries between the next command and the closing invocation.
+//
+// **It fits the `budget` the prompt leaves it** — the prompt is one argv element, refused past
+// `MAX_VALUE_LENGTH` (joshuafolkken/kit#3964) — by dropping the excerpt's head first, since a check
+// reports its verdict last; the tail line always stays.
+function describe(
+	issue: string,
+	context: StopContext,
+	budget: number = agent_role_profile.MAX_VALUE_LENGTH,
+): string {
+	const changed = changed_text(context)
+
+	if (!has_excerpt(context)) return changed
+
+	let dropped = 0
+	let block = excerpt_block(issue, context, changed, dropped)
+
+	while (block.length > budget && dropped < context.excerpt.length - 1) {
+		dropped += 1
+		block = excerpt_block(issue, context, changed, dropped)
+	}
+
+	return block
+}
+
+const run_ship_stop_context = {
+	CHANGED_PATH_LIMIT,
+	EXCERPT_LINE_LIMIT,
+	build,
+	describe,
+	has_excerpt,
+	stop_context_schema,
+}
+
+export type { StopContext }
+export { run_ship_stop_context }

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

@@ -4,6 +4,7 @@ import { git_command } from '#scripts/git/git-command'
 import { main_merge, type MergeOutcome } from '#scripts/git/main-merge'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { error_text } from '#scripts/lib/error-message'
+import { run_ship_overlap } from './run-ship-overlap'
 import { run_ship_scoped } from './run-ship-scoped'
 
 // `josh ship` keeps the branch current with the default branch itself: a default branch that moves
@@ -11,9 +12,9 @@ import { run_ship_scoped } from './run-ship-scoped'
 // merging the default branch again usually resolves it.
 //
 // So the merge happens mechanically: once before the commit (`sync_stage`), and once when
-// the followup fails on a pull request GitHub reports `DIRTY` (`followup_stage`). Only a merge git
-// itself cannot finish stops the ship, and it stops as `conflict`, naming the unmerged paths so the
-// resumed session goes straight to them.
+// the followup fails on a pull request GitHub reports `DIRTY` (`followup_stage`). A conflict only on
+// generated files is regenerated by the merge itself (`main-merge-regenerate.ts`); any other conflict
+// stops the ship as `conflict`, naming the unmerged paths so the resumed session goes straight to them.
 
 const should_forward_stderr = true
 const SUCCESS_EXIT_CODE = 0
@@ -66,12 +67,19 @@ function sync_note(outcome: Exclude<MergeOutcome, { kind: 'conflict' }>): string
 // touches, and once that work is committed the followup merges again on a clean tree. A merge that changed
 // the tree is checked by the gate stage that follows, so the commit never carries
 // an unchecked merge and the gate's record names the merge base the push carries.
-async function sync_stage(): Promise<StepResult> {
+//
+// The merge waits first for any lane whose open pull request changes the same paths
+// (`run-ship-overlap.ts`), so it brings that pull request in before the gate rather than meeting it
+// as `DIRTY` after CI.
+async function sync_stage(issue: string): Promise<StepResult> {
+	const waited = run_ship_overlap.note(await run_ship_overlap.await_overlap(issue))
 	const outcome = await merge_outcome()
 
-	if (outcome.kind === 'conflict') return conflict_result(outcome.files, '')
+	if (outcome.kind === 'conflict') return conflict_result(outcome.files, waited)
+
+	const out = [waited, sync_note(outcome)].filter((line) => line !== '').join('\n')
 
-	return { code: SUCCESS_EXIT_CODE, out: sync_note(outcome) }
+	return { code: SUCCESS_EXIT_CODE, out }
 }
 
 // Any read that fails answers "not conflicting": the followup failure then stands as it was.

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

@@ -33,12 +33,12 @@ function memoized(read: IsMerged): IsMerged {
 
 async function sweep(): Promise<void> {
 	try {
-		const read_merged = memoized(issue_merged.read_merged)
+		const is_merged = memoized(issue_merged.read_merged)
 		const in_flight = backlog_drive_restore.active_issues(
 			await run_event_stream_emit.current_events(),
 		)
-		const lanes = await run_tidy_lanes.tidy_lanes(read_merged, in_flight)
-		const stashes = await run_tidy_stashes.tidy_stashes(read_merged)
+		const lanes = await run_tidy_lanes.tidy_lanes(is_merged, in_flight)
+		const stashes = await run_tidy_stashes.tidy_stashes(is_merged)
 		const report = run_tidy.format_report([...lanes, ...stashes])
 
 		if (report !== undefined) console.error(report)

package/scripts/run/tidy/run-tidy-lanes.ts

@@ -95,8 +95,9 @@ async function tidy_lane(
 	is_merged: IsMerged,
 	in_flight: ReadonlySet<string>,
 ): Promise<Outcome | undefined> {
-	if (in_flight.has(lane.issue)) return undefined
-	if (lane.is_stranded || !(await is_merged(lane.issue))) return undefined
+	if (in_flight.has(lane.issue) || lane.is_stranded || !(await is_merged(lane.issue))) {
+		return undefined
+	}
 
 	return { target: `lane ${session_cite.issue(lane.issue)}`, verdict: await settle(lane) }
 }

package/scripts/safe-chain/project-config.ts

@@ -126,8 +126,13 @@ function merge_project_config(existing: string, workspace: string): string {
 	const aikido = yaml_document.parse_yaml(existing)
 	const safe_chain = read_mapping(aikido['safe-chain'], 'safe-chain')
 	const merged = merge_age(merge_exclusions(safe_chain, exclusions), workspace)
-	if (JSON.stringify(merged) === JSON.stringify(safe_chain)) return existing
-	if (has_nothing_to_write(existing, exclusions, workspace)) return existing
+
+	if (
+		JSON.stringify(merged) === JSON.stringify(safe_chain) ||
+		has_nothing_to_write(existing, exclusions, workspace)
+	) {
+		return existing
+	}
 
 	return replace_safe_chain_block(existing, merged)
 }

package/scripts/sync/sync-hook-safety.ts

@@ -65,8 +65,14 @@ function hook_write_warning(
 	filename: string,
 ): string | undefined {
 	const installed_version = installed_consumer_version(project_root)
-	if (writing_version === undefined || installed_version === undefined) return undefined
-	if (is_safe_to_write_hooks(writing_version, installed_version)) return undefined
+
+	if (
+		writing_version === undefined ||
+		installed_version === undefined ||
+		is_safe_to_write_hooks(writing_version, installed_version)
+	) {
+		return undefined
+	}
 
 	return outdated_install_warning(writing_version, installed_version, filename)
 }

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

@@ -2,9 +2,13 @@
 import { existsSync, globSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { environment_flags } from '@joshuafolkken/kit/env'
+import { core_budget } from '#scripts/gate/core-budget'
 import { execa } from 'execa'
 
 const PNPM = 'pnpm'
+// `--workers`, `--workers=<n>` and Playwright's `-j` short form.
+const WORKER_FLAGS = /^(?:--workers(?:=|$)|-j)/u
 const FAIL_EXIT_CODE = 1
 const ARGV_START = 2
 const PLAYWRIGHT_PACKAGE = path.join('node_modules', '@playwright', 'test')
@@ -45,15 +49,36 @@ function has_e2e_tests(project_directory: string): boolean {
 	return matches.length > 0
 }
 
+// **A local run's worker count is the weight it reserved** (joshuafolkken/kit#3944). Playwright's own
+// default is half the cores, which no ledger entry stood for; CI keeps its config's count, and a
+// count the caller names wins.
+function playwright_arguments(extra_arguments: ReadonlyArray<string>): ReadonlyArray<string> {
+	const is_count_named = extra_arguments.some((argument) => WORKER_FLAGS.test(argument))
+
+	if (is_count_named || environment_flags.is_ci_enabled(process.env['CI'])) return extra_arguments
+
+	return [`--workers=${String(core_budget.CORE_WEIGHTS.e2e)}`, ...extra_arguments]
+}
+
 async function run_playwright(extra_arguments: ReadonlyArray<string>): Promise<number> {
-	const result = await execa(PNPM, ['exec', 'playwright', 'test', ...extra_arguments], {
-		stdio: 'inherit',
-		reject: false,
-	})
+	const result = await execa(
+		PNPM,
+		['exec', 'playwright', 'test', ...playwright_arguments(extra_arguments)],
+		{ stdio: 'inherit', reject: false },
+	)
 
 	return result.exitCode ?? FAIL_EXIT_CODE
 }
 
+// Only a run reserves: a skip starts nothing, and a claim there could wait out a full ledger for it.
+async function run_reserved_playwright(extra_arguments: ReadonlyArray<string>): Promise<number> {
+	return await core_budget.with_command_reservation(
+		core_budget.CORE_WEIGHTS.e2e,
+		async () => await run_playwright(extra_arguments),
+		{ command: 'test:e2e' },
+	)
+}
+
 async function run_guarded_e2e(
 	project_directory: string,
 	extra_arguments: ReadonlyArray<string>,
@@ -61,7 +86,7 @@ async function run_guarded_e2e(
 	const is_installed = is_playwright_installed(project_directory)
 	const has_tests = has_e2e_tests(project_directory)
 	const action = resolve_guard_action(is_installed, has_tests)
-	if (action === 'run') return await run_playwright(extra_arguments)
+	if (action === 'run') return await run_reserved_playwright(extra_arguments)
 
 	console.info(`josh test:e2e: ${SKIP_REASONS[action]} — skipping Playwright e2e.`)
 

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

@@ -1,8 +1,10 @@
 #!/usr/bin/env tsx
 import { existsSync, globSync } from 'node:fs'
+import { availableParallelism } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { PROJECT_ENVIRONMENT_KEYS } from '#ports'
+import { free_cores } from '#scripts/gate/free-cores'
 import { project_checks } from '#scripts/gate/project-checks'
 import { execa } from 'execa'
 import { project_test_script, type ProjectScriptState } from './project-test-script'
@@ -175,11 +177,24 @@ function isolated_unit_environment(
 // Reading the share first and claiming afterwards leaves a window in which two hooks firing together
 // both count "alone" and both run uncapped. Inside the marker the number is identical — this run's own
 // record is now on disk and `is_nested_run` therefore contributes nothing — and the window is gone.
+//
+// **The machine is read only when no count was typed.** The reading waits out a sample window, and a
+// caller's `--maxWorkers` — the gate's cap among them, already bounded by the same reading — wins
+// whatever it says.
+async function vitest_share(vitest_arguments: ReadonlyArray<string>): Promise<number | undefined> {
+	if (unit_worker_share.has_worker_flag(vitest_arguments)) return undefined
+
+	const available_cores = availableParallelism()
+	const free = await free_cores.read({ available_cores })
+
+	return unit_worker_share.current_share(available_cores, unit_worker_share.live_run_count(), free)
+}
+
 async function run_vitest(vitest_arguments: ReadonlyArray<string>): Promise<number> {
 	return await unit_worker_share.with_run_marker(async () => {
 		const sized = unit_worker_share.worker_arguments(
 			vitest_arguments,
-			unit_worker_share.current_share(),
+			await vitest_share(vitest_arguments),
 		)
 		const result = await execa(PNPM, ['exec', 'vitest', ...vitest_arguments, ...sized], {
 			env: isolated_unit_environment(),

package/scripts/test/unit-worker-share.ts

@@ -153,6 +153,22 @@ function resolve_unit_workers(available_cores: number, runs: number): number | u
 	return Math.max(MIN_WORKERS, Math.floor(available_cores / runs))
 }
 
+// **The run count divides the machine; the free cores bound what that division hands out.** The
+// share counts only unit runs, so load from outside the core budget's ledger — Claude sessions, other
+// tools — went unseen: 22 of 38 ledger samples at a load average of 20 or more had vitest as their
+// heaviest process, one at 381% over 30 processes. `free_cores` is `free-cores.ts`'s reading, the
+// cores less that outside load. `undefined` — a CI runner, a CPU quota — and a reading at or above
+// the ceiling both leave `workers` as it was, so an unread or quiet machine changes nothing.
+function cap_to_free(
+	workers: number | undefined,
+	free_cores: number | undefined,
+	available_cores: number,
+): number | undefined {
+	if (free_cores === undefined || free_cores >= (workers ?? available_cores)) return workers
+
+	return Math.max(MIN_WORKERS, Math.floor(free_cores))
+}
+
 // The share this run may take, read from the machine. Separate from `resolve_unit_workers` so that
 // one stays a pure function of two numbers and every test of it can pass them.
 //
@@ -163,10 +179,12 @@ function resolve_unit_workers(available_cores: number, runs: number): number | u
 function current_share(
 	available_cores: number = availableParallelism(),
 	live_runs: number = live_run_count(),
+	free_cores?: number,
 ): number | undefined {
 	const own_run = is_nested_run() ? 0 : SOLO_RUNS
+	const share = resolve_unit_workers(available_cores, live_runs + own_run)
 
-	return resolve_unit_workers(available_cores, live_runs + own_run)
+	return cap_to_free(share, free_cores, available_cores)
 }
 
 function is_worker_flag(argument: string): boolean {
@@ -182,12 +200,15 @@ function is_worker_flag(argument: string): boolean {
 // would make this function's own answer depend on what happened to be running while it was asked, and
 // `f(args, undefined)` takes the default rather than the value — so the case that matters most, "this
 // run is alone", would be the one case no test could express.
+function has_worker_flag(vitest_arguments: ReadonlyArray<string>): boolean {
+	return vitest_arguments.some((argument) => is_worker_flag(argument))
+}
+
 function worker_arguments(
 	vitest_arguments: ReadonlyArray<string>,
 	share: number | undefined,
 ): Array<string> {
-	if (share === undefined) return []
-	if (vitest_arguments.some((argument) => is_worker_flag(argument))) return []
+	if (share === undefined || has_worker_flag(vitest_arguments)) return []
 
 	return [`${WORKER_FLAG}=${String(share)}`]
 }
@@ -229,7 +250,9 @@ const unit_worker_share = {
 	NESTED_VALUE,
 	RUN_PREFIX,
 	SOLO_RUNS,
+	cap_to_free,
 	current_share,
+	has_worker_flag,
 	is_nested_run,
 	live_run_count,
 	marker_path,

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

@@ -51,12 +51,12 @@ type NamedCall = Pick<Span, 'is_bundleable' | 'is_writing' | 'label' | 'targets'
 const RULE_POINTER = '`prompts/collaboration-workflow/turn-batching.md`'
 const STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`
 
-// Includes what to do when the turn was already batching — the guard cannot see the turn it interrupted.
+// Includes what to do when there is nothing to pair — the guard cannot see the turn it interrupted.
 const REASON =
 	`⛔ batching: ${STREAK}. Reissue this with the calls that do not need its result — the test is ` +
 	`whether a call's input needs another call's result, not what kind of call it is (edits are covered ` +
-	`exactly as reads), and it never authorizes weakening a verification gate or a review. Already ` +
-	`batching, or nothing to pair? Reissue it unchanged; this fires once per streak. ${RULE_POINTER}`
+	`exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to ` +
+	`pair? Reissue it unchanged. ${RULE_POINTER}`
 
 // A whole-file write earns a notice, not a refusal: a `Write` cannot be refused safely.
 const NOTICE =

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

@@ -68,8 +68,9 @@ function fork_path(transcript_path: string, agent_id: string): string {
 // **A path that is not a transcript is answered with itself**, since nothing can be derived from it and
 // guessing would name a file in some other layout entirely.
 function transcript_of(transcript_path: string, agent_id: string | null | undefined): string {
-	if (!is_agent_id(agent_id)) return transcript_path
-	if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION)) return transcript_path
+	if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
+		return transcript_path
+	}
 
 	return fork_path(transcript_path, agent_id)
 }

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

@@ -32,8 +32,9 @@ const SEGMENT_PATTERN = /&&|\|\||;|\|/u
 // last, while `||` keeps the first command's and runs the second only when it failed. `|&` is a pipe
 // and is cut here, its `&` left in the fragment that follows.
 const PIPE_PATTERN = /(?<!\|)\|(?!\|)/u
-// What `SEGMENT_PATTERN` cuts on minus the pipe, for reading *inside* one pipe segment.
-const CHAIN_PATTERN = /&&|\|\||;/u
+// What `SEGMENT_PATTERN` cuts on minus the pipe, for reading *inside* one pipe segment — plus the
+// newline, which ends a command as `;` does, so a line typed before the piped check is not read as it.
+const CHAIN_PATTERN = /&&|\|\||;|\n/u
 // A quoted span is text, not shell syntax, and it is removed before the pipe reading below. This
 // repository's issue bodies, comment bodies and commit messages quote command chains constantly, so
 // `--body "cd x && pnpm josh gate | tail"` is a `gh` call and nothing else — a reader that split its
@@ -189,6 +190,15 @@ function unquoted(command: string): string {
 	return without_heredoc_bodies(command).replaceAll(QUOTED_SPAN_PATTERN, ' ')
 }
 
+// Quoted text replaced by spaces of its own length, so an offset found here is the same offset in the
+// command — what a caller cutting the command where the unquoted reading says to needs. `undefined`
+// for a line carrying a heredoc, whose body lines a cut would read as commands of their own.
+function blanked(command: string): string | undefined {
+	if (HEREDOC_MARKER.test(command)) return undefined
+
+	return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => ' '.repeat(span.length))
+}
+
 function discarded_commands(command: string): Array<string> {
 	const plain = unquoted(command)
 
@@ -290,8 +300,8 @@ function drop_redirections(words: ReadonlyArray<string>): Array<string> {
 // **The match's own text is what is sliced off, not a fixed word count.** The prefix is two words in
 // `josh lint`, three in `pnpm josh lint` and four in `pnpm exec josh lint`, so counting words would
 // leave `josh` itself in the argument list for one of the three spellings.
-function josh_arguments(command: string): Array<string> {
-	const text = command_words(command_segment(command)).join(' ')
+function josh_arguments_of_segment(segment: string): Array<string> {
+	const text = command_words(segment).join(' ')
 	const match = JOSH_PATTERN.exec(text)
 
 	if (match === null) return []
@@ -304,15 +314,40 @@ function josh_arguments(command: string): Array<string> {
 	return drop_redirections(words)
 }
 
+function josh_arguments(command: string): Array<string> {
+	return josh_arguments_of_segment(command_segment(command))
+}
+
+// The josh subcommand one segment runs plus every argument it passes, redirections dropped, or `''`
+// for a segment that runs none. **Flags are kept**: which of them ask nothing new (`run:board --chat`)
+// and which turn a read into a write (`run:carry --cut`) is the reader's rule, not this one's.
+function josh_signature_of_segment(segment: string): string {
+	const name = josh_command_of_segment(segment)
+
+	if (name === '') return ''
+
+	return [name, ...josh_arguments_of_segment(segment)].join(' ')
+}
+
+// Every segment's signature, read over the same unquoted chain `josh_commands_of` walks.
+function josh_signatures_of(command: string): Array<string> {
+	return unquoted(command)
+		.split(SEGMENT_PATTERN)
+		.map((segment) => josh_signature_of_segment(segment))
+		.filter((signature) => signature !== '')
+}
+
 const time_shell = {
 	JOSH_PREFIX,
 	bash_command,
 	bash_label,
+	blanked,
 	command_segment,
 	discarded_commands,
 	josh_arguments,
 	josh_command_of,
 	josh_commands_of,
+	josh_signatures_of,
 	leading_word,
 	unquoted,
 }

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

@@ -334,6 +334,7 @@ function to_spans(events: ReadonlyArray<TimelineEvent>, finished: FinishedAt): A
 		label: event.label,
 		josh_command: event.josh_command,
 		josh_commands: event.josh_commands,
+		josh_signatures: event.josh_signatures,
 		check_key: event.check_key,
 		marker: event.marker,
 		is_bundleable: event.is_bundleable,

package/scripts/time-runtime/time-tool-call.ts

@@ -55,6 +55,9 @@ interface ToolCall {
 	// A chained `pnpm josh lint:related && pnpm josh test:related` carries both; the count tables expand
 	// it so the ones `josh_command` drops are still counted.
 	josh_commands: ReadonlyArray<string>
+	// Each of those with the operands it named, flags dropped — what tells `lane:output 1` from
+	// `lane:output 2` once the span has kept no command string. `run-poll-hook.ts` reads it.
+	josh_signatures: ReadonlyArray<string>
 	check_key: string
 	marker: PhaseMarker
 	is_bundleable: boolean
@@ -83,6 +86,7 @@ const NO_CALL: ToolCall = {
 	label: '',
 	josh_command: '',
 	josh_commands: [],
+	josh_signatures: [],
 	check_key: time_single_check.NO_CHECK,
 	marker: time_markers.NO_MARKER,
 	message_id: NO_MESSAGE_ID,
@@ -95,6 +99,7 @@ const UNKNOWN_CALL: ToolCall = {
 	label: UNKNOWN_TOOL,
 	josh_command: '',
 	josh_commands: [],
+	josh_signatures: [],
 	check_key: time_single_check.NO_CHECK,
 	marker: time_markers.NO_MARKER,
 	message_id: NO_MESSAGE_ID,
@@ -111,6 +116,7 @@ function non_bash_call(name: string, input: unknown, message_id: string): ToolCa
 		label: name,
 		josh_command: '',
 		josh_commands: [],
+		josh_signatures: [],
 		check_key: time_single_check.NO_CHECK,
 		marker: time_markers.tool_marker(name, input),
 		message_id,
@@ -132,6 +138,7 @@ function bash_call(input: unknown, message_id: string): ToolCall {
 		label: time_shell.bash_label(command),
 		josh_command,
 		josh_commands: time_shell.josh_commands_of(command),
+		josh_signatures: time_shell.josh_signatures_of(command),
 		check_key: time_single_check.check_key(josh_command, command),
 		marker: time_markers.bash_marker(command),
 		message_id,

package/scripts/version/effective-upstream.ts

@@ -23,8 +23,7 @@ function read_matching_version(manifest_path: string, package_name: string): str
 	const parsed = package_named_version_schema.safeParse(
 		json_value.parse_or_undefined(readFileSync(manifest_path, 'utf8')),
 	)
-	if (!parsed.success) return undefined
-	if (parsed.data.name !== package_name) return undefined
+	if (!parsed.success || parsed.data.name !== package_name) return undefined
 
 	return parsed.data.version
 }
@@ -45,10 +44,10 @@ function walk_up_for_version(start_directory: string, package_name: string): str
 function resolve_from_base(
 	base_url: string,
 	package_name: string,
-	resolve_marker: string | undefined,
+	resolve_marker = package_name,
 ): string | undefined {
 	try {
-		return createRequire(base_url).resolve(resolve_marker ?? package_name)
+		return createRequire(base_url).resolve(resolve_marker)
 	} catch {
 		return undefined
 	}