@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/scripts/time-runtime/time-reported-failure.ts

@@ -2,27 +2,24 @@ import { josh_verdict } from '#scripts/josh/josh-verdict'
 import { status_icons } from '#scripts/lib/status-icons'
 import { z } from 'zod'
 
-// Reading a josh check's failure out of what it printed, when the pipe threw its exit status away
-// (joshuafolkken/kit#1361).
+// Reading a josh check's failure out of what it printed, when the pipe threw its exit status away.
 //
-// joshuafolkken/kit#1309 records how a call came back from the harness's `is_error`, which reports
-// the **tool call** rather than the command inside it. Agents call the verification gate through a
-// pipe almost every time — `pnpm josh gate 2>&1 | tail -40` — and a pipeline exits with `tail`'s
-// status, so a red gate is written back as a call that succeeded. Measured over this machine's kit
-// transcripts for 2026-09-04 onward: 83 `josh gate` calls, 13 of them printing a failure line, and
-// `is_error: true` on none of the 13. The rework figure #1309 exists to expose was therefore blind
-// to exactly the re-runs that motivated it.
+// A span's outcome is read from the harness's `is_error`, which reports the **tool call** rather than
+// the command inside it. Agents call the verification gate through a pipe almost every time —
+// `pnpm josh gate 2>&1 | tail -40` — and a pipeline exits with `tail`'s status, so a red gate is
+// written back as a call that succeeded: measured, `is_error: true` on none of 13 failing gate calls.
+// The rework figure would otherwise be blind to exactly the re-runs it exists to expose.
 //
 // **What is read is josh's own failure line, and only on a call that ran josh.** Every josh command
 // that reports a per-item result opens the failing one with `status_icons.FAIL_ICON`, so a line
 // beginning with that character in the output of a `pnpm josh <cmd>` call is that command saying it
 // failed. The gate's is `✗ verification gate failed: lint (48.2s)`.
 //
-// **Refined by joshuafolkken/kit#1374**: a command that forwards another tool's output states its own
+// **A stated verdict comes first**: a command that forwards another tool's output states its own
 // verdict, and that verdict is read first — the bare icon is only consulted where there is none. See
 // `verdict_answer` below and `josh-verdict.ts`.
 //
-// **Bounded on the other side by joshuafolkken/kit#1379**: that verdict silences the run it summarizes
+// **Bounded on the other side**: that verdict silences the run it summarizes
 // and not everything printed before it. The run begins at the gate's opening `plan:` line — printed
 // once, before any check body exists — and never at a step header, which repeats per check. See
 // `scan_line` here and `is_gate_opening` in `josh-verdict.ts`.
@@ -90,7 +87,7 @@ function is_failure_line(line: string): boolean {
 	return line.trimStart().startsWith(status_icons.FAIL_ICON)
 }
 
-// **A command's own verdict outranks the lines it forwarded** (joshuafolkken/kit#1374). `josh gate`
+// **A command's own verdict outranks the lines it forwarded**. `josh gate`
 // prints the body of a step that skipped or passed with warnings, and that body belongs to eslint,
 // svelte-check, vitest or cspell — one of them opening a line with the failure icon would otherwise
 // make a *green* gate a failed call, and charge the next gate run as rework. Where a verdict line is
@@ -105,8 +102,8 @@ function is_failure_line(line: string): boolean {
 // exists to make going quiet without failing. A forwarded body is printed *before* the verdict that
 // summarizes it, so what follows the last one belongs to whatever ran next and is still read.
 //
-// **And it speaks only for the run in front of it, not for everything printed earlier**
-// (joshuafolkken/kit#1379). "Everything before the verdict" was one-sided: a call that runs a josh
+// **And it speaks only for the run in front of it, not for everything printed earlier**.
+// "Everything before the verdict" was one-sided: a call that runs a josh
 // command stating no verdict and *then* a green gate — `pnpm josh propagate; pnpm josh gate` — is
 // labelled by its first segment, and propagate's `✗ <repo>` rows were thrown away by a verdict printed
 // by the command after them. The run a verdict summarizes begins at that gate's opening `plan:` line,
@@ -141,12 +138,11 @@ function new_scan(): FailureScan {
 // **The reading between the two is the whole fix, and the guard on it is the whole of its safety.**
 // A failure mark printed before the region opened is confirmed here, because the gate had not started
 // yet and the gate's opening line is printed before any body it could forward. One printed inside the
-// region is discarded, which is what joshuafolkken/kit#1374 closed.
+// region is discarded.
 //
-// **No opening line seen means no region, and then nothing is confirmed** — the pre-#1379 behavior
-// exactly. That is the case a `2>&1 | tail -40` produces when the head of the gate's output falls off
-// the top of the window, and reading the surviving body lines there would put #1374's false positive
-// straight back. So the fix is bounded by what it can actually see, and where it cannot see, the
+// **No opening line seen means no region, and then nothing is confirmed.** That is the case a
+// `2>&1 | tail -40` produces when the head of the gate's output falls off the top of the window, and
+// reading the surviving body lines there would count a forwarded failure mark as the gate's own. So the fix is bounded by what it can actually see, and where it cannot see, the
 // figure stays the floor it already was.
 function close_region(scan: FailureScan): void {
 	scan.did_find ||= scan.is_region_open && scan.has_failure_before_region

package/scripts/time-runtime/time-round-trips.ts

@@ -1,6 +1,6 @@
 import { time_spans, type Span } from './time-spans'
 
-// How many times a run stopped and waited for a tool result (joshuafolkken/kit#1304).
+// How many times a run stopped and waited for a tool result.
 //
 // The other `time-*` modules measure *duration*: where the wall clock went, and which command spent
 // it. This measures the one thing duration cannot see. Measured on four runs, the tools themselves
@@ -13,7 +13,7 @@ import { time_spans, type Span } from './time-spans'
 // spans.** Counting calls instead would report a turn that batched four reads as four round trips —
 // which is the improvement, scored as the defect.
 //
-// **Adjacency was the original rule and it was wrong on real transcripts** (joshuafolkken/kit#1406).
+// **Adjacency was the original rule and it was wrong on real transcripts**.
 // It rested on "tool spans sit adjacent exactly when their calls were issued together in one turn",
 // and Claude Code does not write a turn that way: each `tool_use` block is its own assistant line and
 // the harness returns each result as soon as it has one, so a turn issuing three calls is written
@@ -43,10 +43,9 @@ import { time_spans, type Span } from './time-spans'
 //   the model share was right on run #1399 while the turn count was not.
 
 // Below this, a run is issuing about one call per turn: nothing is being batched, and the turn count
-// (which is what the wall clock is charged per) is as high as the call count. Set from the four runs
-// measured on joshuafolkken/kit#1304 — #1251, #1290, #1292 and #1295 — whose densities were 1.13,
-// 1.04, 1.03 and 1.00: every one of them a run in which independent reads and edits went out one per
-// turn. A run that batches even occasionally clears this, so it flags the absence of batching rather
+// (which is what the wall clock is charged per) is as high as the call count. Set from four measured
+// runs whose densities were 1.13, 1.04, 1.03 and 1.00: every one of them a run in which independent
+// reads and edits went out one per turn. A run that batches even occasionally clears this, so it flags the absence of batching rather
 // than grading its degree.
 const CALLS_PER_ROUND_TRIP_FLOOR = 1.5
 const DENSITY_DECIMALS = 2
@@ -95,7 +94,7 @@ function count_calls(spans: ReadonlyArray<Span>): number {
 }
 
 // The nearest span before this one that is not a model span, or `undefined` where none is.
-// **The walk back crosses model spans and stops at everything else** (joshuafolkken/kit#1406): a
+// **The walk back crosses model spans and stops at everything else**: a
 // turn's own calls are separated only by its own model spans, while a human wait means the next turn
 // was composed after an interruption and a continuation means a delegated unit ran in between —
 // neither of which any message could have issued its calls across. A human span that stops the walk
@@ -128,8 +127,8 @@ function continues_turn(spans: ReadonlyArray<Span>, index: number, message_id: s
 // the density in *both* wrong directions at once, one call fewer over one trip more, which is how a
 // turn that batched and delegated could print the warning meant for a turn that did neither.
 //
-// **Two rules, and the adjacency one is the fallback rather than the definition**
-// (joshuafolkken/kit#1406). A call issued beside another in the array is the shape the transcript
+// **Two rules, and the adjacency one is the fallback rather than the definition**.
+// A call issued beside another in the array is the shape the transcript
 // writes when the results arrive together, and it stays as it was — including for a span carrying no
 // message id at all. Everything else asks the id, which is what catches the shape Claude Code
 // actually writes: `use → result → use → result`, one turn, its calls separated by its own model
@@ -158,7 +157,7 @@ interface TripWalk {
 	open: Array<Span> | undefined
 }
 
-// **A model span no longer closes the open trip** (joshuafolkken/kit#1406). It is what sits between
+// **A model span no longer closes the open trip**. It is what sits between
 // two calls of one turn, so closing on it left the turn's second call with no trip to join and the
 // per-tool counts reporting a batched turn as a run of solitary calls. What still closes one is a
 // human wait: the turn after it was composed after an interruption, so its calls belong to a trip of
@@ -179,7 +178,7 @@ function step_trip(walk: TripWalk, span: Span, is_opener: boolean): void {
 	else if (!is_model(span)) walk.open = undefined
 }
 
-// **A round trip as the calls it carried, rather than as a count** (joshuafolkken/kit#1385). The count
+// **A round trip as the calls it carried, rather than as a count**. The count
 // is what this returns the length of, so the two cannot come to disagree about what a round trip is —
 // which is the whole point of asking here rather than grouping the spans a second time next door.
 //
@@ -210,8 +209,8 @@ function turn_key(span: Span, index: number): string {
 	return span.message_id === time_spans.NO_MESSAGE_ID ? `#${String(index)}` : span.message_id
 }
 
-// **How many assistant messages the run's model spans came from — the definition of a turn**
-// (joshuafolkken/kit#1406). Not how many model spans there are: Claude Code writes one line per
+// **How many assistant messages the run's model spans came from — the definition of a turn**.
+// Not how many model spans there are: Claude Code writes one line per
 // content block and repeats the message id on each, so a turn that thought and then issued two calls
 // is three lines and three model spans. Counting the spans reported run #1399's 41 turns as 79, and
 // with them halved every per-turn figure divided by this — `josh time --epic`'s `ms_per_turn` above
@@ -223,7 +222,7 @@ function count_turns(spans: ReadonlyArray<Span>): number {
 }
 
 // What one round trip cost, in whatever unit the numerator carries: calls, for the density the floor
-// above is quoted in, and milliseconds for the price joshuafolkken/kit#1307 added. **One divisor with
+// above is quoted in, and milliseconds for the price per round trip. **One divisor with
 // one guard, rather than a second copy per unit** — the two are the same question about the same
 // denominator, and a guard written into only one of them would print, in the unit that lacked it,
 // exactly the measurement the other withholds.
@@ -252,23 +251,21 @@ const time_round_trips = {
 	CALLS_PER_ROUND_TRIP_FLOOR,
 	count_calls,
 	count_round_trips,
-	// Exported since joshuafolkken/kit#1406, so a turn is defined in the one module that already
-	// defines a round trip rather than as a span filter in the report next door.
+	// Exported so a turn is defined in the one module that already defines a round trip rather than
+	// as a span filter in the report next door.
 	count_turns,
 	format_density,
-	// Exported since joshuafolkken/kit#1385, so the per-tool counts are read off the very groups this
-	// module counts rather than off a second grouping beside them.
+	// Exported so the per-tool counts are read off the very groups this module counts rather than off
+	// a second grouping beside them.
 	group_round_trips,
-	// Exported since joshuafolkken/kit#1309, so the failure aggregation orders a run's spans through
+	// Exported so the failure aggregation orders a run's spans through
 	// the one function that already knows why they need it — a second `toSorted` beside it would be
 	// the clone `CLAUDE.md` prohibits, and the seam it guards (a delegated unit's spans appended
 	// after the parent's) is not one a second copy would keep remembering.
 	in_time_order,
 	is_below_floor,
-	// The four below are exported since joshuafolkken/kit#1406, when the model-gap walk moved to
-	// `time-model-gaps.ts` and needed the same predicates and the same opener test this walk uses. A
-	// private copy there would be the clone `CLAUDE.md` prohibits, in the one place a drift would have
-	// the distribution and the count disagreeing about what a round trip is.
+	// Exported so callers price a round trip with the same divisor and guard rather than a private
+	// copy — the clone `CLAUDE.md` prohibits.
 	per_round_trip,
 }
 

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

@@ -2,7 +2,7 @@ import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
 import { canonical_command } from '#scripts/josh/josh-command-map'
 import { json_value } from '#scripts/lib/json-value'
 
-// Reading a shell command well enough to name what it ran (joshuafolkken/kit#1344).
+// Reading a shell command well enough to name what it ran.
 //
 // It was `time-spans.ts`'s, and it moved out when that file passed its length limit. The seam is the
 // one `time-format.ts` was cut along: this holds no timing knowledge at all — no spans, no
@@ -46,7 +46,7 @@ const CHAIN_PATTERN = /&&|\|\||;/u
 // nothing beyond the reading, while a fragment read as a command answers about work the shell never
 // did, on the shape this repository writes constantly.
 //
-// **Escapes and heredoc bodies are text too** (joshuafolkken/kit#2841). A backslash outside single
+// **Escapes and heredoc bodies are text too**. A backslash outside single
 // quotes makes the next character literal, so `it\'s` opens nothing and a `"` closes only at an
 // unescaped `"`; inside `'…'` a backslash is an ordinary character, so `'C:\'` still closes. A heredoc
 // body is not shell syntax at all — an `it's` there is prose — so it is removed before the quotes are
@@ -141,7 +141,7 @@ function leading_word(command: string): string {
 }
 
 // Every command a pipeline throws the exit status of away — one per `|`-separated segment except the
-// last (joshuafolkken/kit#1556). A shell reports a pipeline with its final command's status, so a
+// last. A shell reports a pipeline with its final command's status, so a
 // check run anywhere earlier has its verdict discarded before anything reads it.
 //
 // **The command of a segment is at the end of its chain, not the start.** `|` binds tighter than `&&`
@@ -208,7 +208,7 @@ function bash_label(command: string): string {
 	return word === '' ? cost_blocks.BASH_TOOL : `${cost_blocks.BASH_TOOL}${BASH_SEPARATOR}${word}`
 }
 
-// **An alias is expanded here, so one command is one name** (joshuafolkken/kit#1789). Every reading
+// **An alias is expanded here, so one command is one name**. Every reading
 // built on this field keyed `pnpm josh ga` and `pnpm josh gate` as two different commands: the
 // per-command table printed them as two rows, the per-invocation table dropped both for having one
 // call each, and — the one with real cost — the failure chain did not see the second as answering the
@@ -229,7 +229,7 @@ function josh_command_of(command: string): string {
 	return josh_command_of_segment(command_segment(command))
 }
 
-// Every josh subcommand a chained call ran, not just the first (joshuafolkken/kit#1883). The standard
+// Every josh subcommand a chained call ran, not just the first. The standard
 // verification form `pnpm josh lint:related && pnpm josh test:related` is two commands in one call, and
 // `josh_command_of` reads only the first segment's — so a table built on that field never counted
 // `test:related`. This reads every segment instead.
@@ -245,8 +245,8 @@ function josh_commands_of(command: string): Array<string> {
 		.filter((name) => name !== '')
 }
 
-// A redirection is not an argument, and keeping one splits a single check into two signatures
-// (joshuafolkken/kit#1383). Measured on run #1379, every `pnpm josh <check>` call there was written
+// A redirection is not an argument, and keeping one splits a single check into two signatures.
+// Measured on run #1379, every `pnpm josh <check>` call there was written
 // `… 2>&1`, so an otherwise identical call written without one would have keyed differently and the
 // repeat between them would have gone uncounted.
 //
@@ -279,7 +279,7 @@ function drop_redirections(words: ReadonlyArray<string>): Array<string> {
 	return kept
 }
 
-// What a `pnpm josh <cmd>` call passes after its subcommand (joshuafolkken/kit#1383).
+// What a `pnpm josh <cmd>` call passes after its subcommand.
 //
 // **Read from the same segment `josh_command_of` reads the subcommand from**, and past the same
 // match. Two calls of one check are told apart by their arguments, so a second reader here would be

package/scripts/time-runtime/time-single-check.ts

@@ -1,7 +1,6 @@
 import { time_shell } from './time-shell'
 
-// Which calls are one verification check run on its own, and what makes two of them the same call
-// (joshuafolkken/kit#1383).
+// Which calls are one verification check run on its own, and what makes two of them the same call.
 //
 // Measured on run #1379, that run issued eight of these — 45.9 seconds of tool time, six of them in
 // the fix phase, each its own round trip — and 18.1 seconds after the last one `josh gate` ran lint,

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

@@ -10,29 +10,26 @@ import { time_transcript_line, type Block, type TranscriptLine } from './time-tr
 const { NO_MESSAGE_ID, parse_line } = time_transcript_line
 const { NO_CALL, UNKNOWN_CALL, UNKNOWN_TOOL, to_tool_call } = time_tool_call
 
-// Turning a session transcript into timed spans (joshuafolkken/kit#1267).
+// Turning a session transcript into timed spans.
 //
 // `cost-*` reads the same files for what a run was billed. This reads the other axis: where its wall
 // clock went. Discovery and reading are `cost-transcript.ts`'s and are reused rather than copied;
 // what is here is the arithmetic, which has no counterpart on the cost side.
 //
-// **Reading one line is `time-transcript-line.ts`'s** since joshuafolkken/kit#1406, when this file
-// passed its length limit — the schemas, the two records a line yields and the parse that produces
-// them. `NO_MESSAGE_ID` and `parse_line` are re-exported below under the names they always had, so
-// the move changed no call site. `cost_blocks`' three type constants are still imported rather than
-// restated.
+// **Reading one line is `time-transcript-line.ts`'s** — the schemas, the two records a line yields
+// and the parse that produces them. `NO_MESSAGE_ID` and `parse_line` are re-exported below, and
+// `cost_blocks`' three type constants are imported rather than restated.
 //
-// **Reading a `tool_use` block into a `ToolCall` is `time-tool-call.ts`'s** since
-// joshuafolkken/kit#3264, when this file reached its length limit again. `UNKNOWN_TOOL` and
-// `to_tool_call` are re-exported below, so that move changed no call site either.
+// **Reading a `tool_use` block into a `ToolCall` is `time-tool-call.ts`'s**; `UNKNOWN_TOOL` and
+// `to_tool_call` are re-exported below.
 //
 // **The partition is by gap, not by pair.** Every span is the interval between two consecutive
 // events, classified by the *later* one: a span ending at an assistant line is model wait, one
 // ending at a tool result is that tool's execution, one ending at a user prompt is human wait.
 // Classifying by pairs instead would double-count parallel tool calls and leave the three shares
 // summing to something other than the elapsed time — the property that makes two runs comparable.
-// Measured against the three sessions joshuafolkken/kit#1267 restored by hand: 49.6 / 73.3 / 54.6
-// minutes, every share within 0.4 points of the hand figure.
+// Measured against three sessions restored by hand: 49.6 / 73.3 / 54.6 minutes, every share within
+// 0.4 points of the hand figure.
 
 const ASSISTANT_TYPE = 'assistant'
 const USER_TYPE = 'user'
@@ -43,7 +40,7 @@ const MODEL_CATEGORY: SpanCategory = 'model'
 const TOOL_CATEGORY: SpanCategory = 'tool'
 const HUMAN_CATEGORY: SpanCategory = 'human'
 
-// How the call this span paid for came back (joshuafolkken/kit#1309).
+// How the call this span paid for came back.
 //
 // **Three answers rather than two.** `unknown` is not a polite `ok`: a fifth of the tool results in
 // the transcripts measured carry no `is_error` at all — a file read, an answered question — and
@@ -67,17 +64,17 @@ const UNKNOWN_OUTCOME: SpanOutcome = 'unknown'
 interface ResultFacts {
 	call_id: string
 	outcome: SpanOutcome
-	// Which guard refused the call this result closed, and `''` for every non-refusal
-	// (joshuafolkken/kit#1913). Carried here for the reason `outcome` is: the result block is gone by
+	// Which guard refused the call this result closed, and `''` for every non-refusal.
+	// Carried here for the reason `outcome` is: the result block is gone by
 	// the time the per-guard refusal breakdown aggregates, and only what was read off it survives.
 	refusal_guard: string
 	// The id the harness assigned when it took this call's command into the background, and `''` for
-	// every other result (joshuafolkken/kit#1662). Fourth field for the reason the others are here:
+	// every other result. Fourth field for the reason the others are here:
 	// the launch's body is the only place the id is written, and the body is gone by the time
 	// anything places the command on the timeline.
 	background_id: string
-	// The stage rows a `pnpm josh followup` call printed into its own output
-	// (joshuafolkken/kit#1445). Third field for the reason the two above are here: the result block is
+	// The stage rows a `pnpm josh followup` call printed into its own output.
+	// Third field for the reason the two above are here: the result block is
 	// gone by the time anything aggregates, so what a table wants from it has to be read off it now.
 	// Empty for every span that is not a measured `followup` invocation.
 	followup_stages: ReadonlyArray<FollowupStage>
@@ -93,8 +90,8 @@ const NO_RESULT: ResultFacts = {
 
 // `ended_ms` is the absolute instant the span closed, so `[ended_ms - duration_ms, ended_ms]` is the
 // interval it occupied. A duration alone cannot say *when*, and two things need that: the CI wait,
-// which is the part of the PR-open→merge window no span covers (joshuafolkken/kit#1268), and the
-// phase breakdown that slices the same array by boundary (joshuafolkken/kit#1269).
+// which is the part of the PR-open→merge window no span covers, and the
+// phase breakdown that slices the same array by boundary.
 //
 // `branch` rides along for the same reason `cost-usage.ts` carries it on a record: it is what
 // `cost_attribute` reads to decide which issue the span belongs to.
@@ -103,17 +100,16 @@ const NO_RESULT: ResultFacts = {
 interface Span extends ToolCall, ResultFacts {
 	category: SpanCategory
 	duration_ms: number
-	// What the call itself took, before any of its minutes were handed to a delegated unit
-	// (joshuafolkken/kit#1591). Carried beside `duration_ms` rather than derived from it, because
+	// What the call itself took, before any of its minutes were handed to a delegated unit.
+	// Carried beside `duration_ms` rather than derived from it, because
 	// nothing downstream could recover it: `time_overlap.trim` replaces `duration_ms` and keeps no
 	// record of what it replaced.
 	//
 	// **The two answer different questions, and a report needs both.** `duration_ms` is this span's
 	// share of the run's wall clock, so the subtraction shortens it wherever a unit covered the same
-	// minutes — without that the four category shares stop reconstructing `elapsed_ms`, which is the
-	// double count joshuafolkken/kit#1287 fixed. This one is what a per-invocation row is asked for:
-	// a `Skill` call that really ran for five minutes was printed as 65 ms, because 65 ms is all the
-	// subtraction had left of it.
+	// minutes — without that the four category shares double-count and stop reconstructing
+	// `elapsed_ms`. This one is what a per-invocation row is asked for: a `Skill` call that really ran
+	// for five minutes would otherwise print as the few milliseconds the subtraction left of it.
 	//
 	// It survives that subtraction because `trim` copies the span and overwrites only `duration_ms`
 	// and `ended_ms`, so every fragment of one call carries the same value — which is why the tables
@@ -122,19 +118,19 @@ interface Span extends ToolCall, ResultFacts {
 	ended_ms: number
 	branch: string
 	// Whether this span is the *remainder* of a call whose middle was given to a delegated unit, cut
-	// out by `time_overlap.trim` (joshuafolkken/kit#1304). One call comes back as two spans there, so
+	// out by `time_overlap.trim`. One call comes back as two spans there, so
 	// anything counting calls rather than intervals has to skip the second — the round-trip block and
 	// the per-tool table's `call_count` both do. Every span the transcript itself yields is `false`;
 	// only the subtraction sets it.
 	is_continuation: boolean
 	// The `pnpm josh <cmd>` this span ran *beside*, where it sits inside a backgrounded command's
-	// window, and `''` everywhere else (joshuafolkken/kit#1662). It is resolved after the walk rather
+	// window, and `''` everywhere else. It is resolved after the walk rather
 	// than read off a call, because the window is not known until the join that closes it has been
 	// seen — so it has `is_continuation`'s shape rather than `marker`'s: every span the walk yields is
 	// empty, and only `time_background.positioned` sets it.
 	background_command: string
 	// When the harness said the command this span launched had finished, and `NO_FINISH` where nothing
-	// said (joshuafolkken/kit#1696). It is the notice's own instant rather than a reading's, so it is
+	// said. It is the notice's own instant rather than a reading's, so it is
 	// keyed to the launch by id at parse time — the notice sits on a line of its own, which is why no
 	// field read off this span's own result could carry it.
 	background_ended_ms: number
@@ -157,7 +153,7 @@ interface Timeline {
 // the empty string, where the next result that carries no `tool_use_id` would match it and be
 // labelled with an unrelated tool — a wrong name where `UNKNOWN_TOOL` is the honest one.
 // A `tool_use` block with the assistant message it was written under, which is the turn that issued
-// it (joshuafolkken/kit#1406). The pair is kept rather than the block alone because the id lives on
+// it. The pair is kept rather than the block alone because the id lives on
 // the *line* and the flatten below is where it would otherwise be lost.
 interface IssuedCall {
 	block: Block
@@ -207,8 +203,8 @@ function event_of(
 // outcome — a file read, an answered question — would otherwise be counted as calls that succeeded,
 // and a run whose whole transcript was written by them would report a measured zero failures.
 //
-// **What the command said outranks what the harness recorded, in one direction only**
-// (joshuafolkken/kit#1361). A josh check run inside a pipeline exits with the pipe's status, so the
+// **What the command said outranks what the harness recorded, in one direction only**.
+// A josh check run inside a pipeline exits with the pipe's status, so the
 // harness writes `is_error: false` over a red gate; the failure line the command printed is the only
 // surviving evidence, and it is read *before* the field. The reverse never happens — a call the
 // harness marked failed is failed whatever it printed.
@@ -250,8 +246,7 @@ function to_event(
 ): TimelineEvent | undefined {
 	// **A model span carries the message its own line belongs to**, which is what makes a turn
 	// countable: Claude Code writes one line per content block and repeats the id on each, so the
-	// lines are what a naive count sees and the id is what says how many turns they were
-	// (joshuafolkken/kit#1406).
+	// lines are what a naive count sees and the id is what says how many turns they were.
 	if (line.type === ASSISTANT_TYPE) {
 		return event_of(line, MODEL_CATEGORY, { ...NO_CALL, message_id: line.message_id })
 	}
@@ -276,15 +271,15 @@ function to_events(
 // interval paid for is the work the later line records, and taking the opening line's branch would
 // attribute the first span after a `josh git` to whatever preceded the branch.
 // The two durations of a span that nothing has taken a share of yet, which is every span a
-// transcript itself yields and every span a test builds (joshuafolkken/kit#1591). Written once here
+// transcript itself yields and every span a test builds. Written once here
 // so no builder can set one and forget the other — the drift would be silent, and would surface as a
 // per-invocation row disagreeing with the transcript it was read from.
 function equal_durations(duration_ms: number): Pick<Span, 'duration_ms' | 'own_duration_ms'> {
 	return { duration_ms, own_duration_ms: duration_ms }
 }
 
-// The four background fields of a span nothing backgrounded, which is every span a test builds
-// (joshuafolkken/kit#1662). Written once here for the reason `equal_durations` above is: three
+// The four background fields of a span nothing backgrounded, which is every span a test builds.
+// Written once here for the reason `equal_durations` above is: three
 // fixtures assemble a `Span` literal, and a field added to two of them is a drift that surfaces only
 // as a table disagreeing with the transcript it was read from.
 type BackgroundFields = Pick<
@@ -368,15 +363,15 @@ function parse_timeline(text: string): Timeline {
 	return {
 		started_ms: events[0]?.timestamp_ms ?? 0,
 		ended_ms: events.at(-1)?.timestamp_ms ?? 0,
-		// **The positioning happens here rather than in a caller** (joshuafolkken/kit#1662): a launch and
+		// **The positioning happens here rather than in a caller**: a launch and
 		// the call that reads its output are in one transcript, and by the time spans have been merged
 		// across sessions and trimmed they are fragments rather than calls.
 		spans: time_background.positioned(to_spans(events, time_background.finished_at(lines))),
 	}
 }
 
-// **"No span was read" is the one criterion every scope withholds a transcript figure on**
-// (joshuafolkken/kit#1295). A run whose transcript could not be attributed, a child of an epic in
+// **"No span was read" is the one criterion every scope withholds a transcript figure on**.
+// A run whose transcript could not be attributed, a child of an epic in
 // that state, and a batch no child contributed to are the same fact asked at three scales, and each
 // used to spell it out for itself — which is how the run scope came to print three `0.0 min` rows
 // beside the epic scope's `not measured` for the very same child.
@@ -401,7 +396,7 @@ const time_spans = {
 	equal_durations,
 	no_background,
 	// Re-exported so the suites that measure how a command is read keep asking one namespace, and so
-	// `time-shell.ts` moving out of this file changed no call site (joshuafolkken/kit#1344).
+	// `time-shell.ts` moving out of this file changed no call site.
 	bash_label: time_shell.bash_label,
 	josh_command_of: time_shell.josh_command_of,
 	josh_commands_of: time_shell.josh_commands_of,

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

@@ -8,7 +8,7 @@ import { time_transcript_line } from './time-transcript-line'
 import { time_writes } from './time-writes'
 
 // Reading a `tool_use` block into the label a span carries — split out of `time-spans.ts` when it
-// reached its line limit (joshuafolkken/kit#3264). `time_spans` re-exports `UNKNOWN_TOOL` and
+// reached its line limit. `time_spans` re-exports `UNKNOWN_TOOL` and
 // `to_tool_call` under the names they always had, so the move changed no call site.
 
 const { NO_MESSAGE_ID } = time_transcript_line
@@ -19,31 +19,31 @@ const UNKNOWN_TOOL = 'unknown'
 // `pnpm josh <cmd>` invocation, and the report drops empty labels rather than printing a bucket.
 //
 // `marker` names the workflow boundary the call is, for the phase breakdown that slices the same
-// spans by stage (joshuafolkken/kit#1269). It is carried here rather than re-derived later because
+// spans by stage. It is carried here rather than re-derived later because
 // the tool's *input* is what decides it, and a span keeps no input — only the label read off it.
 //
-// `is_bundleable` and `targets` are carried for exactly that reason too (joshuafolkken/kit#1344).
+// `is_bundleable` and `targets` are carried for exactly that reason too.
 // Whether a call could have gone out beside another, and what it names, are both read off the input —
 // so a module asking about them after the fact would have nothing to read. `time-bundle-call.ts`
 // decides both; the rule each one follows is stated there.
 //
-// `check_key` is the fourth, and the third time this reason has applied (joshuafolkken/kit#1383). Two
+// `check_key` is the fourth, and the third time this reason has applied. Two
 // runs of one verification check are the same call only if they named the same files, and the files
 // are in the input — so `josh_command` alone cannot say, and nothing downstream could recover it.
 // `time-single-check.ts` decides it.
 //
-// `message_id` is the fifth, and it is the one that says which *turn* a call belongs to
-// (joshuafolkken/kit#1406). It is read off the line the `tool_use` block sat on rather than off the
+// `message_id` is the fifth, and it is the one that says which *turn* a call belongs to.
+// It is read off the line the `tool_use` block sat on rather than off the
 // result that closes the span, because a `tool_result` line carries no message id at all — so a span
 // that did not keep it here could never be attributed to the turn that issued it.
 //
-// `writes` is the sixth, and it is what `targets` could not say (joshuafolkken/kit#1472). `targets`
+// `writes` is the sixth, and it is what `targets` could not say. `targets`
 // names what a call mentioned; `marker` says a call was *an* edit but not of what, and for a tool
 // outside `BUNDLEABLE_TOOLS` it arrived with no target at all. So a consumer subtracting edits from
 // reads — `investigation-reads.ts` — had nothing to subtract for `MultiEdit` / `NotebookEdit`, and
 // nothing at all to tell an in-place `sed -i` from the `sed -n` it shares a label with.
 // `time-writes.ts` decides it, from the input this span is about to discard.
-// `issue` is the seventh, and it is the one `branch` could not carry (joshuafolkken/kit#1617). Under
+// `issue` is the seventh, and it is the one `branch` could not carry. Under
 // lanes the session writing the transcript stays on the default branch while the work runs in a linked
 // work tree, so `branch` names no issue on any line of the run; the `in-progress` label call does, and
 // like every field above it that answer is read off the *input* a span is about to discard.
@@ -51,7 +51,7 @@ const UNKNOWN_TOOL = 'unknown'
 interface ToolCall {
 	label: string
 	josh_command: string
-	// Every josh subcommand the call ran, where `josh_command` is only the first (joshuafolkken/kit#1883).
+	// Every josh subcommand the call ran, where `josh_command` is only the first.
 	// 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>
@@ -60,21 +60,20 @@ interface ToolCall {
 	is_bundleable: boolean
 	targets: ReadonlyArray<string>
 	// Carried beside `targets` because sharing a target means something different depending on it: a
-	// second write to one file is independent work, a read of a file just written is not
-	// (joshuafolkken/kit#1509).
+	// second write to one file is independent work, a read of a file just written is not.
 	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).
+	// transcript asks the same read-only question as the guard.
 	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
+	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding.
+	// 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.
 	has_prior_reference: boolean
 	writes: ReadonlyArray<string>
 	message_id: string
 	issue: number
-	// The background run this call reads the output of, and `''` for every other call
-	// (joshuafolkken/kit#1662). It is the eighth field carried for the reason the seven above are:
+	// The background run this call reads the output of, and `''` for every other call.
+	// It is the eighth field carried for the reason the seven above are:
 	// the id sits in the command string, which a span does not keep, and it is the only thing that
 	// says a `tail` two turns later is the join of a command started minutes ago.
 	reads_background: string