@joshuafolkken/kit 1.1229.0 → 1.1370.0

package/scripts/cost-runtime/cost-corpus.ts

@@ -10,20 +10,20 @@ interface MissingData {
 	malformed_lines: number
 	unreadable_sessions: number
 	// Delegated units whose owning session's issue could not be determined, so their cost is charged
-	// to no issue at all (joshuafolkken/kit#1812). Filled by the attribution, which is the only step
+	// to no issue at all. Filled by the attribution, which is the only step
 	// that knows a unit could not follow its parent; zero from a per-session tally.
 	unattributed_sessions: number
 }
 
-// The corpus of a project's session transcripts, and how each request in it attributes to an issue
-// (joshuafolkken/kit#962, joshuafolkken/kit#1812). Split out of `cost-cli.ts` when that file passed
+// The corpus of a project's session transcripts, and how each request in it attributes to an issue.
+// Split out of `cost-cli.ts` when that file passed
 // its length limit: the CLI parses flags and prints reports, and this is the reading underneath every
 // scope it prints — the same walk `josh time`'s phase costs read through `cost_cli.attributed`.
 
 interface Corpus {
 	sessions: Array<SessionUsage>
 	// Kept beside the sessions so the whole-session scope can re-read its transcript for the two
-	// decompositions (joshuafolkken/kit#1151). Parsed lazily and only for that one file: classifying
+	// decompositions. Parsed lazily and only for that one file: classifying
 	// the content blocks of all 158 transcripts to print one issue's cost would be work nothing reads.
 	files: Array<SessionFile>
 	missing: MissingData
@@ -59,7 +59,7 @@ interface AttributedRecord {
 	baseline_tokens: number
 	// The session this record was read from, and whether that session is a delegated unit. The cost
 	// curve is built from the non-delegated (main-line) sessions' records alone, so it needs both to
-	// group an issue's records back by session and drop the units (joshuafolkken/kit#1853).
+	// group an issue's records back by session and drop the units.
 	session_id: string
 	is_delegated: boolean
 }
@@ -82,7 +82,7 @@ function session_meta(corpus: Corpus): Map<string, SessionMeta> {
 }
 
 // Every distinct issue a session's own records attribute to. A delegated unit reads this from the
-// session that delegated it (joshuafolkken/kit#1812): a `fullrun`'s parent names exactly one, so its
+// session that delegated it: a `fullrun`'s parent names exactly one, so its
 // units follow it; a parent that ran several names them all, and its unattributed unit could belong to
 // any of them.
 function issue_set(records: ReadonlyArray<UsageRecord>): Set<number> {
@@ -116,7 +116,7 @@ function owner_sets(
 }
 
 // A session's records, each tagged with the issue its own branch names — and, for a delegated unit,
-// the parent's sole issue substituted wherever the branch named none (joshuafolkken/kit#1812). A child
+// the parent's sole issue substituted wherever the branch named none. A child
 // that committed carries its own `<N>-` branch exactly as a top-level session does, so it attributes
 // by its own records; only a sub-step that never commits — a review, a survey — carries `main`
 // throughout and falls to the inherited issue. `inherited` is `UNATTRIBUTED_KEY` for a non-delegated
@@ -183,8 +183,8 @@ interface CorpusAttribution {
 	unattributed: Array<ReadonlySet<number>>
 }
 
-// Attribution across the whole corpus, delegated units followed to the session that delegated them
-// (joshuafolkken/kit#1812). The fill-forward walk itself is untouched — a unit is tagged with its
+// Attribution across the whole corpus, delegated units followed to the session that delegated them.
+// The fill-forward walk itself is untouched — a unit is tagged with its
 // parent's issue and a non-delegated session keeps `group_by_issue` exactly as before — so
 // `josh cost --issue` and `josh time`'s phase costs, which both read this, stay in step.
 function attribute_corpus(corpus: Corpus): CorpusAttribution {
@@ -249,8 +249,8 @@ function attributed(corpus: Corpus): Array<AttributedRecord> {
 
 // The in-scope records of each non-delegated (main-line) session, grouped and kept in the order they
 // were read. The curve is built from these: a delegated unit starts from low context, so mixing its
-// records into the positional quartiles breaks the growth curve a hand-off decision reads
-// (joshuafolkken/kit#1853). A single-issue run on one session yields one group; a run resumed in a
+// records into the positional quartiles breaks the growth curve a hand-off decision reads.
+// A single-issue run on one session yields one group; a run resumed in a
 // second session yields two, which the curve then withholds rather than mixing.
 function mainline_records(pairs: ReadonlyArray<AttributedRecord>): Array<Array<UsageRecord>> {
 	const groups = new Map<string, Array<UsageRecord>>()

package/scripts/cost-runtime/cost-pricing.ts

@@ -1,7 +1,7 @@
 import { cost_usage, type UsageTotals } from './cost-usage'
 
 // The current Claude price list, and the three multipliers that make a token's price depend on how
-// it was sent (joshuafolkken/kit#962).
+// it was sent.
 //
 // A run's cost is not "tokens x one rate". A cache read costs a tenth of base input, a 5-minute
 // cache write 1.25x, a 1-hour cache write 2x, and output 5x. On a measured request with
@@ -44,7 +44,7 @@ const CONTEXT_MARKER = '['
 // to its longest prefix that the table knows rather than reported as unknown.
 //
 // The `[1m]` marker is the 1M-context beta, and stripping it to the base rate is confirmed correct,
-// not an approximation (joshuafolkken/kit#1838). The published price list — platform.claude.com
+// not an approximation. The published price list — platform.claude.com
 // "Long context pricing", read 2026-09 — states that Claude 4.6 and later models "include the full
 // 1M token context window at standard pricing (a 900k-token request is billed at the same per-token
 // rate as a 9k-token request)". Every id in `MODEL_PRICES` is 4.6-or-later, so no request has an
@@ -76,7 +76,7 @@ function estimate_cost(totals: UsageTotals, price: ModelPrice): number {
 }
 
 // The five dollar terms `estimate_cost` sums, kept apart so a report can say what a run's dollars
-// were spent on rather than only their total (joshuafolkken/kit#1912). Each is priced by the same
+// were spent on rather than only their total. Each is priced by the same
 // multipliers `estimate_cost` uses — the exported constants above — so the five always sum to
 // `estimate_cost(totals, price)`. It is a decomposition of the same arithmetic, not a second price
 // list, which is why the weights live in the constants both read rather than in either function.
@@ -154,7 +154,7 @@ function total_cost(costs: ReadonlyArray<ModelCost>): { usd: number; unpriced: A
 
 // The priced total in dollars, discarding the unpriced-model list — the one-line composition of
 // `total_cost` over `cost_by_model` that callers reach for when they need only the number, kept here
-// so it is not spelled out at each call site (joshuafolkken/kit#1939).
+// so it is not spelled out at each call site.
 function cost_of(records: ReadonlyArray<ModelUsage>): number {
 	return total_cost(cost_by_model(records)).usd
 }

package/scripts/cost-runtime/cost-tokens.ts

@@ -1,5 +1,4 @@
-// Estimating tokens for the parts of the context the transcript records as text
-// (joshuafolkken/kit#1151).
+// Estimating tokens for the parts of the context the transcript records as text.
 //
 // **Why an estimate exists at all.** The transcript reports real token counts for exactly two
 // things: what each request was billed, and how many of a response's output tokens were thinking.

package/scripts/cost-runtime/cost-transcript.ts

@@ -1,11 +1,12 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { lane_paths } from '#scripts/lane/lane-paths'
 import { file_reader } from '#scripts/lib/read-file'
 import { cost_usage, type UsageRecord } from './cost-usage'
 
-// Finding and reading Claude Code's session transcripts (joshuafolkken/kit#962).
+// Finding and reading Claude Code's session transcripts.
 //
 // They live at `~/.claude/projects/<slug>/<session-id>.jsonl`, where the slug is the working
 // directory with every character that is not a letter, digit or hyphen turned into a hyphen.
@@ -23,7 +24,7 @@ const TRANSCRIPT_ROOT = path.join('.claude', 'projects')
 const TRANSCRIPT_EXTENSION = '.jsonl'
 const SLUG_PATTERN = /[^a-zA-Z0-9-]/gu
 
-// Where a delegated unit's transcript is written (joshuafolkken/kit#1285).
+// Where a delegated unit's transcript is written.
 //
 // `epicrun` and `queue` run each child in a delegated unit, and `gate-fix` / `survey` delegate one
 // step of a run. **None of that lands beside the session's own transcript**: the unit writes to
@@ -45,7 +46,7 @@ function transcript_directory(cwd: string, home: string = homedir()): string {
 }
 
 // The checkout a session's transcripts are filed under, which is not always the one a command runs
-// in (joshuafolkken/kit#1617).
+// in.
 //
 // **A lane is a checkout no session ever ran in.** `epicrun` gives each child a linked work tree and
 // the child prefixes every command with it, but the Claude session itself stays in the main checkout
@@ -100,7 +101,7 @@ function read_directory(directory: string): Array<string> {
 	}
 }
 
-// The lane transcript directories filed under a main checkout's lane root (joshuafolkken/kit#1832).
+// The lane transcript directories filed under a main checkout's lane root.
 //
 // **`session_cwd` resolved a lane to its main checkout, but nothing resolved a main checkout to its
 // lanes.** From the main checkout `own === rewritten`, so the search collapsed to one directory and a
@@ -114,19 +115,21 @@ function read_directory(directory: string): Array<string> {
 // store by the slug prefix every lane of this repository shares — `lane_paths.lane_root` slugged, which
 // honors `JOSH_LANE_ROOT` — rather than any directory that may no longer exist.
 //
-// **A lane's directory is its issue number**, so a lane project slug is exactly `<root-slug>-<digits>`:
+// **A lane's directory is its issue number**, so a lane project slug is exactly `<root-slug>-<issue>`:
 // `lane_paths.lane_directory` joins the root with the issue and the registry sorts lanes by
 // `Number(issue)`. Matching the digits rather than the bare prefix keeps out a coincidental sibling
 // such as `.kit-lanes-backup` and a slug filed under a nested cwd — both share the prefix but are not a
 // lane.
-const LANE_ISSUE_SLUG = /^\d+$/u
-
 function lane_transcript_directories(main_cwd: string, home: string): Array<string> {
 	const projects = path.join(home, TRANSCRIPT_ROOT)
 	const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`
 
 	return read_directory(projects)
-		.filter((name) => name.startsWith(prefix) && LANE_ISSUE_SLUG.test(name.slice(prefix.length)))
+		.filter(
+			(name) =>
+				name.startsWith(prefix) &&
+				issue_number_shape.ISSUE_NUMBER_PATTERN.test(name.slice(prefix.length)),
+		)
 		.map((name) => path.join(projects, name))
 }
 
@@ -134,17 +137,15 @@ function lane_transcript_directories(main_cwd: string, home: string): Array<stri
 // in. Two sources are legitimate, so both are searched and `list_sessions_across` merges what they
 // hold:
 //   - the cwd's own slug — where a *dispatched* lane child writes, because `lane:dispatch` launches it
-//     as a `claude -p fullrun #N` process whose working directory is the lane (joshuafolkken/kit#1749);
+//     as a `claude -p fullrun #N` process whose working directory is the lane;
 //   - every lane transcript directory under the main checkout's lane root — so a report run *from the
-//     main checkout* reaches the lane runs it dispatched (joshuafolkken/kit#1832).
+//     main checkout* reaches the lane runs it dispatched.
 //
-// **A lane never reads the main checkout it resolves to (joshuafolkken/kit#2236).** The reverse of the
-// second source — a lane reading the main checkout's slug — used to be searched as well (the
-// joshuafolkken/kit#1617 case, a session that stayed in the main checkout and only prefixed its
-// commands with the lane path). But `lane:dispatch` now runs the child *in* the lane, so the child's
-// transcript is under the lane's own slug; the main slug held only a connected conversation session's
-// transcript, which the child then measured as its own — its `--cut` verdict read that session's cost
-// and every dispatched child stopped before implementing. So the main slug is no longer a candidate
+// **A lane never reads the main checkout it resolves to.** `lane:dispatch` runs the child *in* the
+// lane, so the child's transcript is under the lane's own slug; the main slug holds only a connected
+// conversation session's transcript, which the child would measure as its own — its `--cut` verdict
+// would read that session's cost and every dispatched child would stop before implementing. So the
+// main slug is not a candidate
 // from a lane, and a lane's measurement reads its own records alone.
 //
 // **Only a checkout that resolves to itself reads the lane root**, which is what keeps the from-main
@@ -175,8 +176,8 @@ interface SessionFile {
 	// units.
 	is_delegated: boolean
 	// How many `subagents/` levels down from a session's own transcript this was found: `0` for a
-	// session's own file, `1` for a unit it delegated, `2` for a unit that unit delegated, and so on
-	// (joshuafolkken/kit#1937). The filesystem is the only record of it — no transcript line carries a
+	// session's own file, `1` for a unit it delegated, `2` for a unit that unit delegated, and so on.
+	// The filesystem is the only record of it — no transcript line carries a
 	// parent link — so the run-tree scope reads depth and the immediate parent from where the file sat.
 	depth: number
 }
@@ -249,7 +250,7 @@ function level_units(
 }
 
 // The units under one `subagents/` directory, and — recursively — the units those units delegated in
-// a `subagents/` of their own (joshuafolkken/kit#1937). A subdirectory beside the transcripts is an
+// a `subagents/` of their own. A subdirectory beside the transcripts is an
 // agent that itself delegated, so its own `subagents/` is walked one level deeper and the qualified
 // id gains another segment. Nested units do not occur today — a subagent has no `Agent` tool to
 // dispatch with — but the run-tree scope's depth is defined by this walk rather than by what exists.
@@ -297,7 +298,7 @@ function list_sessions(directory: string): Array<SessionFile> {
 	)
 }
 
-// Every session found across a set of candidate directories (joshuafolkken/kit#1825), newest first and
+// Every session found across a set of candidate directories, newest first and
 // each `session_id` kept once. `transcript_directories` is what produces the set; a session file lives
 // under exactly one slug, so the candidates normally hold disjoint sets and the dedupe is what keeps a
 // run counted a single time should the same session ever surface under more than one candidate
@@ -331,7 +332,7 @@ function owning_session_id(file: SessionFile): string {
 }
 
 // The immediate parent a delegated unit was written under: everything before the *last* separator of
-// its qualified id (joshuafolkken/kit#1937). `owning_session_id` returns the *root* session — the id
+// its qualified id. `owning_session_id` returns the *root* session — the id
 // before the first separator — which the overlap reader needs; the run-tree scope needs the direct
 // parent instead, so a depth-2 unit links to the depth-1 unit that spawned it rather than to the
 // session at the top. A session's own file has no separator and is its own parent.
@@ -342,7 +343,7 @@ function parent_session_id(file: SessionFile): string {
 }
 
 // Which of a listing is "the run that just finished": the newest transcript that is a session's own
-// rather than one of its delegated units (joshuafolkken/kit#1285).
+// rather than one of its delegated units.
 //
 // **A delegated unit is part of a run, not a run of its own**, and it writes the newer file whenever
 // a session delegates — the parent is waiting while the unit works. Taking the head of the listing
@@ -422,7 +423,7 @@ function read_raw(file: SessionFile): string {
 	return file_reader.read_if_readable(file.path) ?? ''
 }
 
-// The same read, with the failure left visible (joshuafolkken/kit#1439). **An unreadable transcript
+// The same read, with the failure left visible. **An unreadable transcript
 // and an empty one are different answers**, and `read_raw` folds both to `''` — right for a reader
 // that only wants lines to parse, and wrong for one that has to report a transcript as *not
 // measured* rather than as measured at zero. `is_readable` on `SessionUsage` is the same distinction
@@ -432,9 +433,8 @@ function read_optional(file: SessionFile): string | undefined {
 }
 
 // One directory the search looked in, and whether it was there to look in. `exists` tells a directory
-// that was absent from one that was present but held no transcript — the distinction
-// joshuafolkken/kit#1617 found `read_directory` swallowing, which is what let a lane's missing slug
-// read the same as an empty one and delayed finding this bug (joshuafolkken/kit#1825).
+// that was absent from one that was present but held no transcript, so a lane's missing slug does
+// not read the same as an empty one.
 interface SearchedDirectory {
 	path: string
 	exists: boolean
@@ -467,14 +467,14 @@ function describe_searched(directory: SearchedDirectory): string {
 
 // What to say when the discovery above found nothing. It lives here rather than in either command
 // because both `josh cost` and `josh time` reach it, and a second copy would drift the moment one of
-// them learned something about where transcripts live (joshuafolkken/kit#1267). The message, not the
+// them learned something about where transcripts live. The message, not the
 // printing: each command owns its own streams and exit code.
 //
 // **The directories are passed in, not resolved here.** The whole point of the message is to name
 // where the command looked, so they have to be the same paths the search used — resolving them a
 // second time can name a directory that was never searched. Both candidates are listed, each with its
 // own reason (absent, or present but empty), so a run whose lane slug does not exist reads differently
-// from one whose main slug exists and is empty (joshuafolkken/kit#1825).
+// from one whose main slug exists and is empty.
 //
 // "No transcript was found" and "this run cost nothing" are different answers, and only one of them
 // is ever true — which is why neither command may report an empty corpus as a zero.

package/scripts/cost-runtime/cost-usage.ts

@@ -2,8 +2,7 @@ import { json_value } from '#scripts/lib/json-value'
 import { time_instant } from '#scripts/time-runtime/time-instant'
 import { z } from 'zod'
 
-// Reading Claude Code's own session transcripts for what a run actually cost
-// (joshuafolkken/kit#962).
+// Reading Claude Code's own session transcripts for what a run actually cost.
 //
 // **One API response is written to the transcript as several lines.** Every content block —
 // thinking, text, each `tool_use` — becomes its own `assistant` line, and all of them carry the
@@ -65,7 +64,7 @@ interface UsageTotals {
 	thinking_tokens: number
 	// Whether the API actually reported a thinking-token count, kept apart from the count itself
 	// because `thinking_tokens: 0` cannot tell "the model did no thinking" from "the field was
-	// absent" (joshuafolkken/kit#1969). A session row prints "not measured" for the second rather
+	// absent". A session row prints "not measured" for the second rather
 	// than a confident 0%, so the distinction has to survive `sum_totals`; it is OR-combined, so a
 	// session is measured once any one of its requests carried a count.
 	thinking_measured: boolean
@@ -76,9 +75,9 @@ interface UsageRecord {
 	model: string
 	branch: string
 	// The request's instant, as epoch milliseconds — `undefined` where no line of the request carried
-	// a readable timestamp (joshuafolkken/kit#1606). On a single line it is that line's timestamp;
+	// a readable timestamp. On a single line it is that line's timestamp;
 	// after `dedupe` folds the request's several lines into one record it is the *latest* of them,
-	// which is the response-completion instant a cost window is keyed to (joshuafolkken/kit#1899).
+	// which is the response-completion instant a cost window is keyed to.
 	//
 	// **`undefined` rather than a sentinel, for the reason `time_instant` exists**: a request whose
 	// instant cannot be read belongs in the unattributed bucket, and a `0` would place it at the
@@ -210,7 +209,7 @@ function parse_line(line: string): LineOutcome {
 
 // The later of two request instants, treating `undefined` as no reading rather than as an early one:
 // a line that carried no timestamp must not pull a request's instant back to nothing when a sibling
-// line of the same request does carry one (joshuafolkken/kit#1899).
+// line of the same request does carry one.
 function later_instant(left: number | undefined, right: number | undefined): number | undefined {
 	if (left === undefined) return right
 	if (right === undefined) return left
@@ -222,7 +221,7 @@ function later_instant(left: number | undefined, right: number | undefined): num
 // the branch sequence, so a Map (which preserves insertion order) is the right container and a Set
 // of ids plus a filter would be the same thing written twice.
 //
-// **`at_ms` is folded to the request's latest line, not its first (joshuafolkken/kit#1899).** One
+// **`at_ms` is folded to the request's latest line, not its first.** One
 // response is written thinking → text → `tool_use` (see the file header), all sharing one request id,
 // and a round trip's cost window opens at the `tool_use` line — the last of them. Keeping the first
 // line's instant put every tool-issuing request *before* its own window, where it fell to the

package/scripts/cost-runtime/cost-verdict.ts

@@ -1,5 +1,5 @@
 // The `--over` hand-off flag of `josh cost`, kept apart from the CLI wiring because it turns a run
-// into a one-line verdict rather than a table (joshuafolkken/kit#1838). It answers what the next turn
+// into a one-line verdict rather than a table. It answers what the next turn
 // of a session will cost, and takes only the figures its verdict needs — an over measurement — never
 // a whole report. The `--cap` counterfactual it once sat beside was retired in #2016 as readerless.
 
@@ -9,7 +9,7 @@ const UNDER_VERDICT = 'under'
 
 // What `--over` reads of a session: the billed input each request paid, oldest first. The sequence
 // is carried rather than a single sum because the hand-off prices the newest request alone
-// (joshuafolkken/kit#3224) — a sum could not answer what the session's current context costs.
+// — a sum could not answer what the session's current context costs.
 interface OverMeasurement {
 	billed_input_per_request: ReadonlyArray<number>
 }
@@ -17,21 +17,20 @@ interface OverMeasurement {
 // What a turn costs is decided by the accumulated preamble, not by what the turn does, so the
 // marginal cost of a session is the billed input its newest request paid. Measured across one
 // `epicrun` that ran six children in one context: 222k per request during the first child, 645k
-// during the sixth — the same work at 2.9x the price (joshuafolkken/kit#968).
+// during the sixth — the same work at 2.9x the price.
 //
-// **The newest request, not an average.** joshuafolkken/kit#2295 replaced the whole-session average,
-// which lagged a long parent by dozens of requests, with the average of the last ten; that still
-// lagged. A session's billed input only grows between compactions (a unit writes its own transcript),
+// **The newest request, not an average.** A whole-session average lags a long parent by dozens of
+// requests, and even the average of the last ten lags. A session's billed input only grows between compactions (a unit writes its own transcript),
 // so an average smooths no outlier — it only trails the context it averages. On 2026-10-05 wake
-// session 03367124 crossed the threshold at request 65 and its ten-request average at request 70
-// (joshuafolkken/kit#3224). The threshold is a break-even on the *current* context
+// session 03367124 crossed the threshold at request 65 and its ten-request average at request 70.
+// The threshold is a break-even on the *current* context
 // (`context-cut-payback.ts`), so the current context is what it is compared against.
 function per_request_cost(measurement: OverMeasurement): number {
 	return measurement.billed_input_per_request.at(-1) ?? 0
 }
 
-// The bare over/under decision, without a report: `run:status` reads this same verdict read-only
-// (joshuafolkken/kit#2165), so the comparison lives here once rather than being copied there. A
+// The bare over/under decision, without a report: `run:status` reads this same verdict read-only,
+// so the comparison lives here once rather than being copied there. A
 // threshold of exactly `cost` is under, matching the `>` the printed report used.
 function classify(
 	measurement: OverMeasurement,
@@ -41,7 +40,7 @@ function classify(
 }
 
 // The stderr line names which request was priced, so the reader can tell the newest request's cost
-// from an average over the session (joshuafolkken/kit#3224).
+// from an average over the session.
 function over_summary(measurement: OverMeasurement, limit: number): string {
 	const total = measurement.billed_input_per_request.length
 

package/scripts/cost-runtime/own-session.ts

@@ -1,7 +1,7 @@
 import { agent_session_environment } from '#scripts/josh/agent-session-environment'
 import { cost_transcript, type SessionFile } from './cost-transcript'
 
-// Which transcript in a listing is the *calling* session's own (joshuafolkken/kit#2403).
+// Which transcript in a listing is the *calling* session's own.
 //
 // **The mtime was measuring another session.** `latest_own_index` took the newest non-delegated
 // transcript as "the run that just finished", which is right for a report run after a run ends but

package/scripts/cost-runtime/transcript-cwd.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 
-// `--path <dir>` names the target project whose transcripts to read, resolved to an absolute path
-// (joshuafolkken/kit#1987). The transcript slug is derived from the exact cwd string and
+// `--path <dir>` names the target project whose transcripts to read, resolved to an absolute path.
+// The transcript slug is derived from the exact cwd string and
 // `~/.claude/projects/<slug>` was written from an absolute one, so a relative `--path` would slugify
 // to a folder that was never written. Shared by `josh cost` and `josh time` so the two resolve a
 // target identically — a second copy of this rule is how one of the two quietly stops finding it.

package/scripts/delegation/delegation-cli.ts

@@ -2,7 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { delegation_policy } from './delegation-policy'
 
-// `josh delegate <step>` — may this step run in a cheaper execution tier? (joshuafolkken/kit#969)
+// `josh delegate <step>` — may this step run in a cheaper execution tier?
 //
 // A command rather than a paragraph, for the reason `josh review:level` is one: a rule an agent
 // applies from memory is a rule an agent can talk itself out of, and this is the rule that decides
@@ -36,15 +36,15 @@ const FLAG_PREFIX = '-'
 // Every reading of the argument goes through this one function, because the guard and the branch
 // disagreeing about surrounding whitespace is the defect itself: the guard trimmed and `run` did
 // not, so `josh delegate ' --list'` passed as a known flag and then fell through to a verdict about
-// a step called ` --list` (joshuafolkken/kit#1096). The policy lookup trims too, which is why
-// `josh delegate ' --help'` had already slipped past an untrimmed guard (joshuafolkken/kit#969).
+// a step called ` --list`. The policy lookup trims too, which is why
+// `josh delegate ' --help'` had already slipped past an untrimmed guard.
 function normalized(argument: string): string {
 	return argument.trim()
 }
 
 // A step name never starts with a dash, so anything that does is a flag — and the only flag this
 // command has is `--list`. Without this, `josh delegate --help` answered `keep`: a mistyped
-// invocation would read as a verdict about a step called `--help` (joshuafolkken/kit#969).
+// invocation would read as a verdict about a step called `--help`.
 function is_unknown_flag(argument: string): boolean {
 	const trimmed = normalized(argument)
 

package/scripts/delegation/delegation-policy.ts

@@ -1,4 +1,4 @@
-// Which steps of a run may be delegated to a cheaper execution tier (joshuafolkken/kit#969).
+// Which steps of a run may be delegated to a cheaper execution tier.
 //
 // **The decision takes no judgement.** "This one is simple enough" is a judgement made under cost
 // pressure, and cost pressure resolves it toward "simple enough" exactly when a mistake is most
@@ -23,19 +23,18 @@ interface DelegatableStep {
 	verifier: string
 }
 
-// Where the pre-implementation reading stops being cheaper in the main line (joshuafolkken/kit#1426).
+// Where the pre-implementation reading stops being cheaper in the main line.
 //
 // **A count, not a forecast.** The reads are counted as they are made rather than predicted before
 // the investigation starts, so nothing here rests on guessing how large it will be. Two files the run
 // will not edit stay in the main line, because delegating costs two extra main-line turns — one to
-// write the brief, one to read the result, about 18 seconds at run #1406's measured 8.8 s of model
+// write the brief, one to read the result, about 18 seconds at roughly 8.8 s of model
 // wait per turn — and below the threshold that round trip costs more than carrying the text.
 const INVESTIGATION_FILE_THRESHOLD = 3
 
-// The same boundary for searches, counted in turns (joshuafolkken/kit#3139). A `grep` carries no file
-// text, so it never reached the file count — yet across 100 lane transcripts on 2026-10-04, 424 turns
-// were searches alone and 160 of them came third or later since the last edit or delegation, each
-// re-reading the whole main-line context. Three keeps the first two searches, which locate an edit
+// The same boundary for searches, counted in turns. A `grep` carries no file
+// text, so it never reaches the file count — yet a search that comes third or later since the last
+// edit or delegation re-reads the whole main-line context all the same. Three keeps the first two searches, which locate an edit
 // target, in the main line and sends the continuing sweep to a unit.
 const INVESTIGATION_SEARCH_TURN_THRESHOLD = 3
 
@@ -50,10 +49,9 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 	},
 	{
 		name: 'epic-child',
-		// One row, two entry points: an epic's child under `epicrun` and one named issue of a
-		// `backlogrun` are the same unit — same brief, same summary, same verifier
-		// (joshuafolkken/kit#1149, folded from `queue` into `backlogrun` by joshuafolkken/kit#1984). A
-		// second row for the batch would be the clone `CLAUDE.md` prohibits.
+		// One row, two entry points: an epic's child and one named issue of a `backlogrun` are the same
+		// unit — same brief, same summary, same verifier. A second row for the batch would be the clone
+		// `CLAUDE.md` prohibits.
 		does: "run one child of a batch end to end in an isolated unit — an epic's child or one named issue of a `backlogrun` alike — plan, verification gate, PR, merge — and return only its summary to the parent loop",
 		verifier:
 			"the parent reads the child's state from GitHub with `pnpm josh issue:state`, not from the summary; a child reported done but not merged is still open, which is the failure showing rather than a run continuing, and its own gate, `/code-review` and CI ran inside the unit before `followup` would touch the PR",
@@ -61,9 +59,9 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 	{
 		name: 'followup-filing',
 		// The late-run follow-up filing chain — `issue:file` (which scouts, lints, labels and runs
-		// epic:bundle itself, joshuafolkken/kit#2808) → epic --add — is a dependency chain `batch:guard`
+		// epic:bundle itself) → epic --add — is a dependency chain `batch:guard`
 		// correctly keeps one call per step, and what makes it expensive is the ~340k context it runs in
-		// at the tail of a run, not the step count (joshuafolkken/kit#1892). A fresh unit runs the same
+		// at the tail of a run, not the step count. A fresh unit runs the same
 		// chain at a small context, and the review round cap already composed the finding text, so what
 		// the unit is handed is mechanical: run the commands and act on their deterministic answers. This
 		// is not `batch:guard`'s business — delegation only moves the chain to a cheaper context.
@@ -77,7 +75,7 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 		// which is why `design` is rejected below. What is delegated is the *writing* of one unit of that
 		// list, and only a unit whose files are disjoint from every other dispatched unit: two subagents
 		// editing one file in parallel race on it. `pnpm josh fanout` confirms that disjointness
-		// mechanically, so the split is read off the file sets rather than judged (joshuafolkken/kit#2345).
+		// mechanically, so the split is read off the file sets rather than judged.
 		does: 'implement one file-disjoint unit of the Step 0 change list in an isolated subagent — the files it edits shared with no other dispatched unit, confirmed by `pnpm josh fanout` — and return the edited files, never a summary standing in for the diff; the main line keeps integration and the verification gate. Units that share a file, or an Issue that will not split, stay serial',
 		verifier:
 			"the parent runs the whole integrated change through `pnpm josh gate` and a `/code-review` subagent it would run anyway — a unit's mistake fails the same gate and review a serial edit passes through, so delegating writes nothing the backstop does not already catch, and the `pnpm josh fanout` disjointness removes the one failure parallelism adds, two units colliding on a file",
@@ -101,7 +99,7 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 	},
 	{
 		name: 'lane-failure-investigation',
-		// The `backlogrun` parent's counterpart of `investigation` (joshuafolkken/kit#2947). The parent
+		// The `backlogrun` parent's counterpart of `investigation`. The parent
 		// orchestrates and never implements, yet it read a failed lane's logs, records and sources in its
 		// own context — about 150 grep / cat / sed calls on 2026-10-02 — and every later request of the
 		// batch re-read them. The verifier is `investigation`'s, and so is the boundary: the unit reports

package/scripts/delegation/duplicate-read-guard.ts

@@ -10,10 +10,9 @@ import { time_spans, type Span } from '#scripts/time-runtime/time-spans'
 import { investigation_reads } from './investigation-reads'
 
 // Refuse the second whole-file `Read` of a path whose content has not changed since the run last read
-// it (joshuafolkken/kit#2298). Measured across the latest five lanes, a run re-read the same unchanged
-// path 8.0 times on average — `#2282` read `pre-gate-cut.md` three times — and each round trip pays
+// it. Left alone, a run re-reads the same unchanged path again and again, and each round trip pays
 // ~17 seconds to return text the run already holds. The remedy is the one `investigation-guard.ts`
-// already proved: intervene in the `PreToolUse` decision rather than describe the rule in prose.
+// applies: intervene in the `PreToolUse` decision rather than describe the rule in prose.
 //
 // **It is unchanged content that is caught, never a repeat read.** The transcript says *when* the run
 // last read the path; the filesystem says *whether* it has changed since. A file whose `mtime` is
@@ -24,12 +23,12 @@ import { investigation_reads } from './investigation-reads'
 //
 // **How it speaks is decided by the one-place lane enumeration, exactly as the batching guard's is.**
 // On the interactive main line a refusal is guidance, so the guard `refuse`s; in a dispatched lane
-// child a denial ends the headless turn with nothing committed (joshuafolkken/kit#2138), and the
-// duplicates the Issue measured are in those very children — so there it is a `notice`, nudging the run
+// child a denial ends the headless turn with nothing committed, and the
+// duplicates mostly occur in those very children — so there it is a `notice`, nudging the run
 // without killing it. `lane-guard-policy.ts` is the single source of both modes.
 //
 // **The escape hatch is on by default**, for `investigation-guard.ts`'s reason: a distributed guard
-// nobody enables leaves the Issue where it started. The variable buys a way to switch it off without
+// nobody enables leaves the problem where it started. The variable buys a way to switch it off without
 // editing the settings file — debugging the guard, or a session whose re-reads really are all needed.
 const SWITCH_ENV_KEY = 'JOSH_DUPLICATE_READ_GUARD'
 const LANE_GUARD_ID = 'duplicate-read'
@@ -45,12 +44,12 @@ const GLOB_CHARACTERS = /[*?]/u
 const REASON = `⛔ duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`
 
 // The same guidance carried without a `permissionDecision`, for a dispatched lane child where a denial
-// would end the turn (joshuafolkken/kit#2138). It nudges rather than blocks, so the run survives.
+// would end the turn. It nudges rather than blocks, so the run survives.
 const NOTICE = `⚠ duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new — scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`
 
 // **A paginated read is a read of a different region, not a repeat.** A run that read lines 1–100 and
 // now wants 101–200 needs the second call, so a read carrying an `offset` or a `limit` is never the
-// whole-file re-read this guard is about — the count the Issue measured is whole-file reads.
+// whole-file re-read this guard is about.
 function is_paginated(input: Record<string, unknown>): boolean {
 	return input['offset'] !== undefined || input['limit'] !== undefined
 }
@@ -163,7 +162,7 @@ function is_redundant_reread(tail: string, call: GuardedCall, fired_at_ms: numbe
 }
 
 // **How this guard behaves for the session in hand, from the one-place enumeration** — `refuse` on the
-// main line, `notice` in a dispatched lane child (joshuafolkken/kit#2298). The enumeration reads the
+// main line, `notice` in a dispatched lane child. The enumeration reads the
 // dispatch mark against this checkout's own issue only for a mode it would change, so a person working
 // in a lane sees the guard refuse exactly as the main line does.
 function duplicate_mode(): LaneGuardMode {
@@ -178,7 +177,7 @@ function is_candidate(call: GuardedCall): boolean {
 
 // A refusable call is refused only where the mode is `refuse`. A lane child is `notice`, so it reaches
 // here and is withheld the refusal — the notice branch carries the guidance instead, because a refusal
-// ends a headless child's turn (joshuafolkken/kit#2138).
+// ends a headless child's turn.
 function should_block_here(tail: string, call: GuardedCall, refused_at_ms: number): boolean {
 	if (duplicate_mode() !== 'refuse') return false
 

package/scripts/delegation/fanout-cli.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { fanout, type FanoutUnit } from './fanout'
 
 // `josh fanout <unit-files> <unit-files> …` — may the Step 0 change list be cut into file-disjoint
-// units and dispatched in one fan-out turn? (joshuafolkken/kit#2345)
+// units and dispatched in one fan-out turn?
 //
 // A command rather than a paragraph, for the reason `josh delegate` is one: "these units look
 // independent" is a judgement made under the same cost pressure, and the answer is mechanical — read

package/scripts/delegation/fanout.ts

@@ -1,5 +1,5 @@
 // Whether the Step 0 change list can be cut into file-disjoint units and dispatched in one fan-out
-// turn, or must stay serial because two proposed units would edit the same file (joshuafolkken/kit#2345).
+// turn, or must stay serial because two proposed units would edit the same file.
 //
 // **File-disjointness is the necessary condition, and it is mechanical.** Two subagents editing the
 // same file in parallel race on that file — the later write lands on top of the earlier, or the gate