@joshuafolkken/kit 1.1240.0 → 1.1373.0

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

@@ -6,12 +6,12 @@ import { time_shell } from './time-shell'
 const { BASH_TOOL } = cost_blocks
 
 // What one call has to say about itself before anything can ask whether it could have gone out
-// beside another (joshuafolkken/kit#1344).
+// beside another.
 //
 // `time-round-trips.ts` counts how many times a run stopped, and `time-density.ts` says the count is
 // too high while the run is still going. Neither can say **which** of those stops were avoidable, and
-// that is the number joshuafolkken/kit#1344 was filed for: the estimate it carries — 33 of 136 round
-// trips — was arithmetic on a target density, not a reading of what the run actually did.
+// that is the number this reads: an estimate drawn from a target density is arithmetic, not a
+// reading of what the run actually did.
 //
 // **Two facts, and both have to be read while the input is in hand.** A span keeps no input, for the
 // reason `time-spans.ts` states beside `marker`: the tool's input is what decides the answer, and by
@@ -36,7 +36,7 @@ const { BASH_TOOL } = cost_blocks
 // or a stop for a person.
 const BUNDLEABLE_TOOLS = new Set(['Edit', 'Glob', 'Grep', 'Read', 'WebFetch', 'WebSearch', 'Write'])
 
-// The tools that launch a *fresh* subagent (joshuafolkken/kit#1854). Both spellings occur across
+// The tools that launch a *fresh* subagent. Both spellings occur across
 // harnesses — this one names it `Agent`, others `Task` — and `time-batch-guard.ts` already treats the
 // two the same. They are deliberately not `time-parent-turns.ts`'s wider dispatch set: `SendMessage`
 // continues an existing agent and is dependent by nature, so a fan-out could never have included it.
@@ -46,7 +46,7 @@ const LAUNCH_TOOLS = new Set(['Agent', 'Task'])
 
 // A launch whose prompt builds on an earlier agent's *finding* rather than on the codebase as it
 // stands — the one dependency `time-agent-bundles.ts` cannot see from an intervening write, because a
-// read-only investigation chain writes nothing between its links (joshuafolkken/kit#1847). It is a
+// read-only investigation chain writes nothing between its links. It is a
 // marker scan and therefore a floor: a prompt that quotes the prior finding without any of these
 // phrases reads as independent, which is the same output-only blind spot this module documents beside
 // `targets`. It never over-calls — a marker present is treated as dependent, which drops the launch
@@ -170,7 +170,7 @@ const MUTATION_WORDS = new Set([
 	'wget',
 ])
 
-// The read-only `pnpm josh` bookkeeping subcommands (joshuafolkken/kit#1875). Every `pnpm josh …`
+// The read-only `pnpm josh` bookkeeping subcommands. Every `pnpm josh …`
 // leads with `pnpm`, which is a mutation word above so the writing josh commands — `gate`, `followup`,
 // `git` — are turned away; that same leading word turned the read-only ones away too, so the batching
 // guard never saw the bookkeeping calls the Issue measured going out one per turn, and `Bundling:`
@@ -242,7 +242,7 @@ const FLAG_PREFIX = '-'
 const PATH_SEPARATOR = '/'
 const MIN_TARGET_LENGTH = 3
 
-// The tools that write. **Kept here rather than in the guard** (joshuafolkken/kit#1509): the guard
+// The tools that write. **Kept here rather than in the guard**: the guard
 // held its own copy, and the sequence builder had no way to ask at all — so a run of edits to one
 // file was read as a chain of dependent calls and no sequence ever formed. One answer, one place.
 const WRITING_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write', 'NotebookEdit'])
@@ -272,8 +272,7 @@ interface BundleFacts {
 	targets: ReadonlyArray<string>
 	// Whether the call **certainly** rewrites what it names. **Two writes to one file do not depend on
 	// each other** — the text is already held, so both belong in one turn — while a write after a read
-	// of the same file genuinely does. `time-bundles.ts` reads this to tell the two apart
-	// (joshuafolkken/kit#1509).
+	// of the same file genuinely does. `time-bundles.ts` reads this to tell the two apart.
 	is_writing: boolean
 	// Whether the call **might** write, which is a different question and needs the opposite bias.
 	//
@@ -283,8 +282,8 @@ interface BundleFacts {
 	// dependency *removed*, so `sed -n '1,200p' x.ts` twice would read as a bundleable pair when the
 	// second may well have needed the first. Same bias, opposite consequences, so they are two fields.
 	may_write: boolean
-	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding
-	// (joshuafolkken/kit#1854). `false` for every call that is not a launch, and for a launch whose
+	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding.
+	// `false` for every call that is not a launch, and for a launch whose
 	// prompt names no back-reference marker. `time-agent-bundles.ts` reads it to break a fan-out group
 	// that a read-only investigation chain would otherwise slip through, since such a chain writes
 	// nothing between its links for the intervening-write test to catch.
@@ -306,7 +305,7 @@ function not_bundleable(): BundleFacts {
 }
 
 // Whether a tool name is a fresh subagent launch. Exported so `time-agent-bundles.ts` reads the one
-// set rather than keeping a second copy of it (joshuafolkken/kit#1854).
+// set rather than keeping a second copy of it.
 function is_launch_tool(name: string): boolean {
 	return LAUNCH_TOOLS.has(name)
 }
@@ -339,7 +338,7 @@ function josh_subcommand(command: string): string | undefined {
 // line falls through. An alias is resolved to its canonical name first, so the allow-list holds
 // canonical names alone. Everything not on the list falls
 // through to the read/mutation test, which is what keeps `josh gate` / `followup` / `git`
-// non-bundleable (joshuafolkken/kit#1875).
+// non-bundleable.
 function is_read_josh(command: string): boolean {
 	if (COMMAND_CHAIN.test(command)) return false
 
@@ -365,8 +364,7 @@ function may_write_command(command: string): boolean {
 // one shell line that certainly rewrites a file *and* is bundleable is the in-place `sed`: `sed` is on
 // the read list because `sed -n` prints, so the flag is what separates the two spellings. Everything
 // else answers `false` — a genuine write missed here only leaves a sequence broken the way it already
-// was, while a read caught here would have its dependency removed, which is the failure that matters
-// (joshuafolkken/kit#1509).
+// was, while a read caught here would have its dependency removed, which is the failure that matters.
 // **The one segment that runs the command, with its quoted text removed first — never the whole
 // line.** Each half closes an over-call, and this predicate feeds the dependency test, so an
 // over-call removes a dependency that is really there:
@@ -382,8 +380,8 @@ function write_segment(command: string): string {
 
 // **The certain half of the write question, asked in one place for both readers.** `time-writes.ts`
 // answers *which* files an in-place `sed` wrote and this module answers *whether* it wrote at all;
-// they were two implementations of the same test and disagreed in both directions
-// (joshuafolkken/kit#1509). The predicate lives here because `time-writes.ts` already imports this
+// they were two implementations of the same test and disagreed in both directions.
+// The predicate lives here because `time-writes.ts` already imports this
 // module, so the reverse direction would be a cycle.
 function is_in_place_sed(segment: string): boolean {
 	if (time_shell.leading_word(segment) !== IN_PLACE_COMMAND) return false
@@ -466,7 +464,7 @@ function tool_facts(name: string, input: unknown): BundleFacts {
 	// A tool names what it does, so here the two questions have the same answer.
 	const writes = { is_writing: WRITING_TOOLS.has(name), may_write: WRITING_TOOLS.has(name) }
 	// Only a launch is asked, and only a launch can answer `true` — a non-launch tool has no prompt to
-	// build on a prior finding (joshuafolkken/kit#1854).
+	// build on a prior finding.
 	const has_prior_reference = LAUNCH_TOOLS.has(name) && prompt_references_prior(input)
 
 	if (!BUNDLEABLE_TOOLS.has(name)) return { ...not_bundleable(), ...writes, has_prior_reference }
@@ -478,7 +476,7 @@ function tool_facts(name: string, input: unknown): BundleFacts {
 // second reader here — the two answers have to be the same one, or a call could be labelled by one
 // command and classified by another.
 //
-// **The quoted spans come off before the targets are read** (joshuafolkken/kit#1611). `words_of`
+// **The quoted spans come off before the targets are read**. `words_of`
 // treats a quote as a separator rather than as a boundary, and `/` is not a separator at all — so
 // `sed -i '' 's/old/new/' scripts/one.ts` yielded `s/old/new` beside the real path, and
 // `investigation-reads.ts` then held a file that no edit could ever name pending for the rest of the
@@ -500,8 +498,8 @@ function bash_facts(command: string): BundleFacts {
 	}
 
 	// A read-only `josh` bookkeeping command is bundleable even though `pnpm` leads it and is a mutation
-	// word: the allow-list above is the read-only half the leading-word test could not reach
-	// (joshuafolkken/kit#1875). Its writes are already `false` — no `>`, no in-place `sed` — so the guard
+	// word: the allow-list above is the read-only half the leading-word test could not reach.
+	// Its writes are already `false` — no `>`, no in-place `sed` — so the guard
 	// can refuse a run of them and `Bundling:` can count them recoverable.
 	if (is_read_josh(command)) {
 		return {
@@ -526,7 +524,7 @@ function bash_facts(command: string): BundleFacts {
 }
 
 // The facts for one call named the way a caller holding a raw tool invocation names it — a tool and
-// its input, with nothing unwrapped yet (joshuafolkken/kit#1390).
+// its input, with nothing unwrapped yet.
 //
 // **It exists so the live guard and the parser cannot disagree about what a call is.** `time-spans.ts`
 // reaches the two functions above directly because it has already read the shell command out of the
@@ -545,27 +543,27 @@ const time_bundle_call = {
 	bash_facts,
 	call_facts,
 	tool_facts,
-	// Exported for `time-agent-bundles.ts` (joshuafolkken/kit#1854), which asks the launch question of a
+	// Exported for `time-agent-bundles.ts`, which asks the launch question of a
 	// span's `label` — the tool name for a non-Bash call — so the set lives in one place.
 	is_launch_tool,
-	// Exported for `time-writes.ts` (joshuafolkken/kit#1472), which asks what a call *wrote* rather
+	// Exported for `time-writes.ts`, which asks what a call *wrote* rather
 	// than what it named. The extraction is the same one either way — a second copy of it would let a
 	// path be recognized as a target when read and missed when written.
 	targets_in,
 	tool_targets,
-	// Exported for the batching guard's own word scan (joshuafolkken/kit#1390), so the two scanners
+	// Exported for the batching guard's own word scan, so the two scanners
 	// cannot come to disagree about where one word of a shell line ends and the next begins.
-	// Exported for the read-fold notice (joshuafolkken/kit#2311), which offers `read:files <path>` only
+	// Exported for the read-fold notice, which offers `read:files <path>` only
 	// over file-shaped targets — a bare directory like `scripts/` is a target here but not something
 	// `read:files` can read, so the notice reuses this test rather than keep a second copy that could
 	// drift from what counts as a file path.
 	has_extension,
-	// Exported for `time-writes.ts` (joshuafolkken/kit#1509), which needs the same two answers to say
+	// Exported for `time-writes.ts`, which needs the same two answers to say
 	// *which* files an in-place `sed` wrote. Two copies of this test disagreed in both directions at
 	// once — one called a piped `grep -i` a write, the other missed a bundled `sed -ni`.
 	write_segment,
 	is_in_place_sed,
-	// Exported for the drift test in `time-bundle-call.test.ts` (joshuafolkken/kit#1875), which pins that
+	// Exported for the drift test in `time-bundle-call.test.ts`, which pins that
 	// every name here is a real `josh` command and none of them writes.
 	READ_JOSH_SUBCOMMANDS,
 }

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

@@ -3,11 +3,10 @@ import { time_format } from './time-format'
 import { time_round_trips } from './time-round-trips'
 import { time_spans, type Span } from './time-spans'
 
-// How many of a run's round trips were avoidable, read from the run rather than assumed
-// (joshuafolkken/kit#1344).
+// How many of a run's round trips were avoidable, read from the run rather than assumed.
 //
 // Three runs in a row came in at 1.10–1.12 calls per round trip against a 1.50 floor, and neither the
-// end-of-run warning (joshuafolkken/kit#1304) nor the live line (joshuafolkken/kit#1329) moved the
+// end-of-run warning nor the live line moved the
 // number. The Issue's estimate of what batching would return — 33 round trips of 136, about 4.8
 // minutes — was arithmetic on the floor: it assumed every call could be bundled to 1.50 and said
 // nothing about which ones actually could. **A mechanism proposed on that figure would be sized by an
@@ -42,7 +41,7 @@ const SAVING_LABEL = 'recoverable wait'
 // transcript has no per-tool answer either, and a table printed under a `not measured` heading would
 // be the empty-means-nothing-to-recover reading this block refuses everywhere else.
 const BY_TOOL_LABEL = 'recoverable by tool'
-// The one label the spread-apart series contributes (joshuafolkken/kit#1854). Both launch spellings —
+// The one label the spread-apart series contributes. Both launch spellings —
 // `Agent` here, `Task` elsewhere — collapse into this one row, so the reconciliation stays balanced.
 const AGENT_ROW_LABEL = 'Agent'
 // The per-tool rows sit one level under that row. Two spaces rather than a separate column, because
@@ -62,7 +61,7 @@ const FIRST_CALL = 1
 // what it leaves out is exactly what `unattributed_round_trips` below then reports.
 const NO_LABEL = ''
 
-// One tool's share of what the run could have recovered (joshuafolkken/kit#1607). `sequence_count` is
+// One tool's share of what the run could have recovered. `sequence_count` is
 // the number of sequences this tool contributed a recoverable trip to, not the number of calls it
 // made — a tool appearing four times inside one sequence is one sequence to go and look at.
 interface BundleToolRow {
@@ -75,7 +74,7 @@ interface BundleToolRow {
 // batched everything genuinely has no sequence, and a run whose transcript was never read has none
 // either — printing `0` for both would report the first as though it were the second.
 //
-// **`by_tool` is what makes the count actionable** (joshuafolkken/kit#1607). `recoverable_round_trips`
+// **`by_tool` is what makes the count actionable**. `recoverable_round_trips`
 // says how many turns could have been one and nothing about *whose* turns they were, so a diag that
 // read only it could name a density and never a tool — and the tool was then found by reading the
 // transcript by hand, once per run.
@@ -141,7 +140,7 @@ function shares_target(left: ReadonlyArray<string>, right: ReadonlyArray<string>
 // earlier one's result", and for a read after a write it is a good one — an `Edit`'s `old_string`
 // came from the `Read` before it.
 //
-// **Between two writes it is not** (joshuafolkken/kit#1509). A second edit to a file already held
+// **Between two writes it is not**. A second edit to a file already held
 // needs nothing from the first, so both belong in one turn — and treating the pair as dependent is
 // what kept the guard silent for a whole run. `extend` below does not merely decline to count such a
 // pair: it *flushes* the sequence and restarts it at the conflicting call, so a stretch of single-call
@@ -183,7 +182,7 @@ function is_turn_boundary(span: Span): boolean {
 // The walk's three running pieces: the calls of the round trip currently open, the sequence being
 // extended, and the sequences already closed.
 //
-// **`closed` keeps the calls rather than their lengths** (joshuafolkken/kit#1607). A length is all the
+// **`closed` keeps the calls rather than their lengths**. A length is all the
 // three totals need, and it is also everything the per-tool breakdown cannot be rebuilt from — the
 // labels are gone by the time anything asks. Retaining the spans is what lets one walk answer both,
 // and a second walk over the same rule would be the clone `CLAUDE.md` prohibits.
@@ -225,7 +224,7 @@ function close_trip(walk: Walk): void {
 
 // Whether this span is still the turn whose calls are pending. **A turn's calls are separated by its
 // own model spans**, because Claude Code writes one line per content block and the harness returns
-// each result as it arrives (joshuafolkken/kit#1406) — so closing the trip on every model span read
+// each result as it arrives — so closing the trip on every model span read
 // one batched turn as several single-call ones and offered it back as a sequence that could have been
 // bundled, which it already was. An absent id matches nothing, leaving the adjacency reading intact
 // for a transcript that wrote none.
@@ -286,7 +285,7 @@ function tally_for(tallies: Map<string, ToolTally>, label: string): ToolTally {
 	return created
 }
 
-// **Attribution is per call, not per sequence** (joshuafolkken/kit#1607). A sequence of `n` calls
+// **Attribution is per call, not per sequence**. A sequence of `n` calls
 // holds `n - 1` avoidable trips, and the call that made each of them its own turn is the one after
 // the first — so each trip goes to *that* call's tool. Attributing a whole sequence to one tool would
 // have named a tool only where every call in the sequence shared one, and a real run's sequences are
@@ -338,7 +337,7 @@ function attributed_of(rows: ReadonlyArray<BundleToolRow>): number {
 // arrive in time order: a delegated unit's are appended after the parent's, and `time_corpus`
 // concatenates one session after another. Walked in array order, two turns from different sessions
 // would read as consecutive and be counted as a sequence nobody could have batched.
-// The spread-apart launch series folded in as one row (joshuafolkken/kit#1854). Appended and re-sorted
+// The spread-apart launch series folded in as one row. Appended and re-sorted
 // rather than pushed in place, so the heaviest-first order still holds; omitted entirely when it
 // recovered nothing, so a run that fanned out its launches shows no empty `Agent` row. Its whole count
 // enters the total below beside it, which is what keeps `unattributed_round_trips` at zero.
@@ -387,7 +386,7 @@ function build_bundles(spans: ReadonlyArray<Span>): BundleTotals {
 }
 
 // The sequence the walk is still inside when the spans run out — the trailing run of consecutive
-// single-call bundleable turns (joshuafolkken/kit#1390).
+// single-call bundleable turns.
 //
 // **Neither `close_trip` nor `flush` is called, and that is the whole difference from
 // `build_bundles`.** The report closes the walk because it is pricing a run that has ended; a guard

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

@@ -1,7 +1,7 @@
 import { time_command_key } from './time-command-key'
 import type { Span } from './time-spans'
 
-// What "the same call" means, in one place (joshuafolkken/kit#1979).
+// What "the same call" means, in one place.
 //
 // Two readers ask it and must agree. `time-guard-refusals.ts` asks whether a refused call was later
 // re-issued unchanged — the false-positive hint on the guard breakdown — and `time-batch-guard.ts`

package/scripts/time-runtime/time-command-key.ts

@@ -1,6 +1,6 @@
 import { time_spans, type Span } from './time-spans'
 
-// What counts as *the same command* across a run's spans (joshuafolkken/kit#1311).
+// What counts as *the same command* across a run's spans.
 //
 // Two questions need it and used to answer it separately: the failure chain asks whether a call
 // repeats one that just failed, and the per-invocation listing asks which calls belong on one row.
@@ -22,7 +22,7 @@ import { time_spans, type Span } from './time-spans'
 const UNNAMED_KEY = ''
 
 // **The parameter is the two fields it reads, not the whole `Span`.** A full span satisfies it, and so
-// does a `ToolCall` the batching guard builds for a live call (joshuafolkken/kit#1979) — the key has
+// does a `ToolCall` the batching guard builds for a live call — the key has
 // to mean the same thing whether it is read off a recorded span or the call about to repeat it.
 function command_key(span: Pick<Span, 'label' | 'josh_command'>): string {
 	if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY

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

@@ -1,11 +1,12 @@
 import { closeSync, fstatSync, openSync, readSync } from 'node:fs'
 import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
 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'
 
-// The disk half of the live density line (joshuafolkken/kit#1329): find the transcript, read enough
+// The disk half of the live density line: find the transcript, read enough
 // of it, and remember when the line was last emitted.
 //
 // **It rides the hook that already runs, and adds no second one.** `.claude/settings.json` wires
@@ -13,8 +14,8 @@ import { time_hook_transcript } from './time-hook-transcript'
 // tool would put a process start in front of all ~250 calls of a run to say something on a handful of
 // them.
 //
-// **`Bash` is in that list because the edit half was measured missing its audience**
-// (joshuafolkken/kit#1337). Riding the edit hook was chosen on run #1299, where `Edit` was the
+// **`Bash` is in that list because the edit half was measured missing its audience**.
+// Riding the edit hook was chosen on run #1299, where `Edit` was the
 // most-called tool at 65 calls — and that run no longer represents how these sessions work. Of the
 // ten most recent in this checkout, **seven called `Edit` and `Write` zero times**: they edit through
 // `sed` instead, and they are the same sessions measured at 1.00–1.31 against the 1.50 floor, so the
@@ -50,8 +51,8 @@ const NEVER_MS = 0
 // `tool_input` the formatter half uses, so a file is named rather than searched for — no
 // home-directory walk.
 //
-// **`agent_id` is what makes a delegated unit answerable with its own transcript**
-// (joshuafolkken/kit#1424). The path in the payload is the *parent* session's, whichever agent issued
+// **`agent_id` is what makes a delegated unit answerable with its own transcript**.
+// The path in the payload is the *parent* session's, whichever agent issued
 // the call, so without this field the line a fork read described the parent's calls per round trip —
 // a number about a run the reader is not in. `time-hook-transcript.ts` carries the derivation.
 const payload_schema = z.object({
@@ -72,7 +73,7 @@ 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
+// The call that has just run, as the payload names it — 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 {
@@ -116,11 +117,7 @@ function last_notice_ms(source: string): number {
 
 	if (raw === undefined) return NEVER_MS
 
-	try {
-		return notice_schema.parse(JSON.parse(raw)).notified_at_ms
-	} catch {
-		return NEVER_MS
-	}
+	return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? NEVER_MS
 }
 
 // **Arming the throttle is best-effort, and never costs the line.** The caller prints and exits, so

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

@@ -2,12 +2,12 @@ import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
 import { time_round_trips } from './time-round-trips'
 import { time_spans, type TranscriptLine } from './time-spans'
 
-// The round-trip density a run can be told **while it is still running** (joshuafolkken/kit#1329).
+// The round-trip density a run can be told **while it is still running**.
 //
 // `time-round-trips.ts` already computes the number this reads, and `josh time` already warns on it
 // — after the run has ended. Measured on run #1299, that report changed nothing: the density stayed
 // at 1.08 with 159 of 172 tool-issuing turns making a single call, because the norm
-// joshuafolkken/kit#1304 shipped as prose in `CLAUDE.md` reaches a reader who has already finished.
+// stated as prose in `CLAUDE.md` reaches a reader who has already finished.
 // What was missing is the number arriving in time to change the next turn.
 //
 // **The density is `time_round_trips`, reused rather than restated.** A second calculation here
@@ -25,8 +25,8 @@ import { time_spans, type TranscriptLine } from './time-spans'
 // to skip — which costs more than the line saves.
 const MIN_ROUND_TRIPS = 10
 // At most one line per this interval, per checkout. The line lands in the run's context and stays
-// there, so a reminder with no throttle would spend exactly the budget joshuafolkken/kit#1322 is
-// about: 65 edits of run #1299 would have carried 65 copies of it. Five minutes is roughly 30 round
+// there, so a reminder with no throttle would spend the very context budget it is
+// meant to save: 65 edits of run #1299 would have carried 65 copies of it. Five minutes is roughly 30 round
 // trips at
 // the 9.7s each cost in that run — often enough to reach the phase that is drifting, rare enough that
 // a whole run pays well under a thousand tokens for the feedback.
@@ -121,7 +121,7 @@ function is_due(reading: DensityReading, since_last_ms: number): boolean {
 // 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. `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.
+// have shared a turn, 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)

package/scripts/time-runtime/time-followup-stage.ts

@@ -1,13 +1,13 @@
 import { git_followup_stages, type FollowupStage } from '#scripts/followup/git-followup-stages'
 
-// Reading `followup`'s own stage rows back out of what it printed (joshuafolkken/kit#1445).
+// Reading `followup`'s own stage rows back out of what it printed.
 //
-// joshuafolkken/kit#1349 gave `pnpm josh followup` a per-stage block — one
-// `followup stage: <name> <n> s` row per lap — and declared the prefix as a constant so a reader
-// could be added without matching a string the printer is free to reword. **There was no reader.**
-// `josh time` sees a `followup` invocation as one Bash span, so the breakdown existed only on the
-// screen of whoever happened to be watching that run: two runs could not be compared stage by stage,
-// and a transcript recorded last week could not be read at all.
+// `pnpm josh followup` prints a per-stage block — one
+// `followup stage: <name> <n> s` row per lap — and declares the prefix as a constant so a reader
+// can be added without matching a string the printer is free to reword. This is that reader.
+// `josh time` sees a `followup` invocation as one Bash span, so without it the breakdown exists only
+// on the screen of whoever happened to be watching that run: two runs cannot be compared stage by
+// stage, and a transcript recorded last week cannot be read at all.
 //
 // **The prefix is imported rather than retyped**, which is the whole of what keeps this from being a
 // guess about another module's output — the shape `time-reported-failure.ts` already uses for

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

@@ -1,4 +1,4 @@
-// The column and number formatting every timing report is laid out through (joshuafolkken/kit#1309).
+// The column and number formatting every timing report is laid out through.
 //
 // It was `time-report.ts`'s until three renderers shared it: the run scope's own tables, the epic
 // scope's child rows, and the failure block `time-failures.ts` prints. Two of those already reached
@@ -29,18 +29,18 @@ const MINUTES_WIDTH = 9
 const NOT_MEASURED = 'not measured'
 // What a row says instead of a rate when there was no round trip to divide by. It sits here rather
 // than in `time-report.ts` because two blocks print it — the round-trip price and the bundling block —
-// and `time-bundles.ts` cannot import `time-report.ts`, which imports it (joshuafolkken/kit#1344).
+// and `time-bundles.ts` cannot import `time-report.ts`, which imports it.
 const NO_CALLS = 'no tool call to divide'
 // How many rows of a table any of these reports prints. Capped, because a long run touches thirty-odd
 // distinct leading commands and a table that long is read by nobody. `--json` carries every row the
 // report holds, so the display cap costs a caller nothing.
 //
 // **It moved here when the segment and per-invocation tables became the fourth and fifth renderers to
-// need it** (joshuafolkken/kit#1311). Those two cannot import `time-report.ts`, which imports them —
+// need it**. Those two cannot import `time-report.ts`, which imports them —
 // and a second cap beside a second renderer is exactly the drift this file was split out to prevent.
 const MAX_ROWS = 15
 
-// **The parenthetical says "this report" rather than "them all"** (joshuafolkken/kit#1301): since
+// **The parenthetical says "this report" rather than "them all"**: since
 // `--top` can cut the record itself before either rendering, a promise that `--json` carries every row
 // *there ever was* would be false beside a `--top` above this display cap — and the report would then
 // contradict its own truncation note. What was cut from the record, if anything, is said in `notes`;
@@ -74,7 +74,7 @@ function format_share(part: number, whole: number): string {
 // to the cent, a per-round-trip figure finer), so the decimals are the caller's and only the `$` and
 // the `toFixed` are shared. It sits here beside the other number formatters rather than in one block,
 // for the reason `format_minutes` does: a second copy beside the second renderer is how two cost rows
-// of one report come to punctuate a dollar amount two ways (joshuafolkken/kit#1606).
+// of one report come to punctuate a dollar amount two ways.
 function usd(amount: number, decimals: number): string {
 	return `$${amount.toFixed(decimals)}`
 }

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

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
 
-// Which transcript a Claude Code hook payload is actually about (joshuafolkken/kit#1424).
+// Which transcript a Claude Code hook payload is actually about.
 //
 // **A hook fired for a forked agent's tool call is handed the *parent* session's transcript.** Both
 // events this package wires carry the same session fields, and neither of them names the fork's own
@@ -10,8 +10,8 @@ import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
 // `<projects>/<slug>/<session-id>/subagents/agent-<agent-id>.jsonl`.
 //
 // **So every reader built on `transcript_path` alone has been reading the wrong run inside a fork**,
-// and two of them are: the batching guard (joshuafolkken/kit#1390) and the live density line
-// (joshuafolkken/kit#1329). Measured on 551 forked review agents in this checkout, the guard refused
+// and two of them are: the batching guard and the live density line.
+// Measured on 551 forked review agents in this checkout, the guard refused
 // **zero** calls — while a replay of the same transcripts through the fork's own file refuses 1–4 per
 // review round. The parent's timeline is frozen for as long as a fork runs, because the fork's lines
 // go to the fork's file: its open sequence never advances, so it either never reaches the limit or

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

@@ -1,4 +1,4 @@
-// One decision about an unparseable timestamp, made once (joshuafolkken/kit#1268).
+// One decision about an unparseable timestamp, made once.
 //
 // Both halves of a run carry dates from somewhere else — the transcript's `timestamp` and GitHub's
 // `created_at` / `merged_at` / check-run times — and both have to answer the same question about a

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

@@ -1,7 +1,7 @@
 import { cost_attribute } from '#scripts/cost-runtime/cost-attribute'
 import { json_value } from '#scripts/lib/json-value'
 
-// Which workflow boundary a tool call marks (joshuafolkken/kit#1269).
+// Which workflow boundary a tool call marks.
 //
 // The per-tool totals answer "which command is slow" and say nothing about "which *stage* is long".
 // A stage is bounded by things a transcript can be read for, so this module is the one rule for what
@@ -14,7 +14,7 @@ import { json_value } from '#scripts/lib/json-value'
 // would be a second rule for the same thing. What is left is four: the plan comment, the first
 // edit, the code-review invocation, and the instant the workflow itself opened.
 //
-// **The workflow boundary has two spellings, and both are the same marker** (joshuafolkken/kit#1299).
+// **The workflow boundary has two spellings, and both are the same marker**.
 // A run is not a session: the transcript attributed to an issue reaches back into whatever the
 // session was doing before the keyword was typed, so without a marker for "the run starts here"
 // that earlier conversation is measured as part of it. Loading the `workflow-commands` skill is the
@@ -22,22 +22,18 @@ import { json_value } from '#scripts/lib/json-value'
 // them performs on GitHub — so the earliest of the two is taken and neither is required, which is
 // what keeps a delegated unit (whose parent loaded the skill) and a resumed run measurable.
 //
-// **The review boundary sits on whatever call the main line spends the review inside**, and since
-// joshuafolkken/kit#1855 that is an `Agent` call rather than a `Skill` one. Before it, the main line
-// loaded `/code-review` through the `Skill` tool and that call returned three to four minutes later
-// with the finding list — so the `Skill(code-review)` call carried the review's whole duration and
-// was the marker. #1855 moved the review into a forked subagent launched with the `Agent` tool, and
-// the main line no longer loads the skill at all: the `Skill(code-review)` call now lives inside the
-// fork's own transcript, where it returns instantly (it only loads the skill text), and the review's
+// **The review boundary sits on whatever call the main line spends the review inside**, which is an
+// `Agent` call: the review runs in a forked subagent, and the `Skill(code-review)` call lives inside
+// the fork's own transcript, where it returns instantly (it only loads the skill text). The review's
 // real wall clock is the fork's own `Read`/`grep` spans. Those spans carry no marker of their own, so
-// they inherit the marker of the parent span they run inside — the `Agent` call (`time-overlap.ts`,
-// joshuafolkken/kit#1439). Left unmarked that parent deletes the phase rather than moving it, which is
-// the ~0 ms `review` joshuafolkken/kit#1846 measured. So the `Agent` launch is marked here, exactly
-// as the `Skill` call was, and the old `Skill(code-review)` marker stays for pre-#1855 transcripts.
+// they inherit the marker of the parent span they run inside — the `Agent` call (`time-overlap.ts`).
+// Left unmarked that parent deletes the phase rather than moving it, leaving a ~0 ms `review`. So the
+// `Agent` launch is marked here, and the `Skill(code-review)` marker stays for older transcripts in
+// which the main line loaded the skill itself.
 //
 // **The launch is recognized by its prompt carrying both `/code-review` and `review:attest`.** The
 // first is the instruction to invoke the review skill; the second is the attestation line
-// `pnpm josh review:brief` emits into the brief the launch passes verbatim (joshuafolkken/kit#1522).
+// `pnpm josh review:brief` emits into the brief the launch passes verbatim.
 // Neither alone is enough: an investigation subagent about the review tooling quotes `/code-review`
 // in prose and is handed no brief, so `review:attest` is what tells a genuine review launch from a
 // discussion of one — measured against five real launches, it admits the review and rejects every
@@ -59,7 +55,7 @@ const SKILL_KEY = 'skill'
 const REVIEW_SKILL = 'code-review'
 const WORKFLOW_SKILL = 'workflow-commands'
 
-// The forked review launch (joshuafolkken/kit#1846). `Agent` is the tool the main line spawns the
+// The forked review launch. `Agent` is the tool the main line spawns the
 // review subagent with, and `prompt` is where the instruction to it lives.
 const AGENT_TOOL = 'Agent'
 const PROMPT_KEY = 'prompt'
@@ -99,7 +95,7 @@ const BODY_FLAG_PATTERN = /--body(?:-file)?\b/u
 // The API path is required alongside it for the reason the plan boundary requires one: a command that
 // merely quotes the flag, which this repository's own issue bodies do, is not the call.
 // The number is captured because the same call is the only place a run states, in its own transcript,
-// which issue it is running (joshuafolkken/kit#1617). Capturing changes nothing for the `test` above
+// which issue it is running. Capturing changes nothing for the `test` above
 // it — the boundary is still the whole match.
 // **The trailing `(?!\/)` is what keeps the capture on the issue being labelled.** `labels[]=in-progress`
 // only has to appear somewhere in the command, and the capture takes the leftmost match — so one call
@@ -111,7 +107,7 @@ 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
+// **`run:entry` applies the label itself now**, 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.
@@ -173,8 +169,8 @@ function is_run_start(command: string): boolean {
 
 // 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**
-// (joshuafolkken/kit#1617): the session writing the transcript stays on the default branch while the
+// **Attribution's other evidence is the branch, and a lane run has none to give**:
+// the session writing the transcript stays on the default branch while the
 // child's commands run in a linked work tree, so `gitBranch` says `main` on every line and
 // `cost_attribute` has nothing to fill forward. This call is what is left, and it is the right thing
 // to be left with — it is the run naming its own issue, once, and `time-sessions.ts` already treats

package/scripts/time-runtime/time-phase-names.ts

@@ -5,7 +5,7 @@
 // grew past its length limit as phases were added to it, and this is the half with nothing to decide
 // — it says what a phase *is*, while the file it left decides which one a span belongs to. Nothing
 // here imports the classifier, so the dependency runs one way and the next phase added costs one
-// line rather than a fresh argument about where to put it (joshuafolkken/kit#1331).
+// line rather than a fresh argument about where to put it.
 
 type PhaseName =
 	| 'plan'
@@ -71,12 +71,12 @@ const PHASE_ORDER: ReadonlyArray<PhaseName> = [
 // transcript was read at all, rather than on a marker.
 //
 // **They are withheld on exactly the terms the three transcript category rows are**
-// (joshuafolkken/kit#1295) — no span read at all. `wait` printing `0.0 min` where nothing was read
+// — no span read at all. `wait` printing `0.0 min` where nothing was read
 // asserts that nobody waited, and the run that produces it is the one a reader is least able to check.
 // Keying every one of them off the same criterion is also what keeps `wait` + `wait-outside` equal to
 // the `human wait` category row: they are withheld together or printed together, never some of each.
 //
-// **`wait-outside` is in this set rather than detected on the run's edges** (joshuafolkken/kit#1331),
+// **`wait-outside` is in this set rather than detected on the run's edges**,
 // which is where it differs from `pre-run` and `post-run`. Its zero is not a claim about an unchecked
 // half, because those two rows report the same two boundaries in their own right — a reader seeing
 // `pre-run  not detected` beside `wait-outside  0.0 min` already knows that edge was never found, and