@joshuafolkken/kit 1.1136.0 → 1.1178.0

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

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

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

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

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

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

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

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

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

@@ -79,6 +79,13 @@ const ERROR_TEXT_LIMIT = 256
 // shared constant exists because each guard writes the literal in its own reason, so the one place a
 // refusal is *detected* names it here.
 const REFUSAL_MARKER = '⛔'
+// The label the harness puts in front of a PreToolUse hook's deny reason, naming the hook and the tool.
+const HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u
+// A line that is one bare verdict token — `cut`, `busy`, `not-a-lane` — the single word a josh verdict
+// command prints on standard output (joshuafolkken/kit#3223). How many are kept bounds the field the
+// way `ERROR_TEXT_LIMIT` bounds `error_text`.
+const TOKEN_LINE = /^[a-z][a-z-]*$/u
+const TOKEN_LINE_LIMIT = 8
 
 interface Block {
 	type: string
@@ -111,6 +118,11 @@ interface Block {
 	// the parsed block rather than by re-scanning the body downstream. `''` where the result was not a
 	// `⛔` refusal, so a reader tells "no guard spoke" from "this guard spoke" without a second parse.
 	refusal_guard: string
+	// The bare-token lines of a result that did not fail, and `[]` for every other block
+	// (joshuafolkken/kit#3223). It obeys the same prohibition as `error_text` — what is kept is a few
+	// single words, never the body — and it exists so the verdict a josh command answered with
+	// (`run:cut`'s `cut`) is read from the parsed block rather than by searching the raw line.
+	token_lines: ReadonlyArray<string>
 	// The id the harness assigned to a command it took into the background, and `''` for every other
 	// block (joshuafolkken/kit#1662). It is the fourth field read off the body under the same
 	// prohibition as the three above — what is kept is the id, never the text it was read from — and
@@ -159,8 +171,12 @@ function block_names(
 // before the first `:` — `⛔ pre-gate cut: …` is `pre-gate cut`. A reason with no colon (a headline
 // like `⛔ scoped checks not green on this tree`) is taken whole. Reading the opening rather than
 // searching the body is what stops a result that merely quoted a reason being read as a refusal.
+//
+// **The harness writes the reason behind its own label** — `PreToolUse:Edit hook error: ⛔ …` — so that
+// label is stripped before the opening is read (joshuafolkken/kit#3223). Without it no live refusal
+// carried a guard: the fixtures wrote the bare `⛔` body and passed while every recorded one read `''`.
 function guard_from_refusal(text: string): string {
-	const trimmed = text.trimStart()
+	const trimmed = text.trimStart().replace(HOOK_ERROR_LABEL, '')
 	if (!trimmed.startsWith(REFUSAL_MARKER)) return ''
 
 	const headline = trimmed.slice(REFUSAL_MARKER.length).split('\n', 1)[0]?.trimStart() ?? ''
@@ -169,6 +185,14 @@ function guard_from_refusal(text: string): string {
 	return (colon === -1 ? headline : headline.slice(0, colon)).trim()
 }
 
+function token_lines_of(text: string): Array<string> {
+	return text
+		.split('\n')
+		.map((line) => line.trim())
+		.filter((line) => TOKEN_LINE.test(line))
+		.slice(0, TOKEN_LINE_LIMIT)
+}
+
 // **The body is flattened once and both readers are handed the text.** `result_text` is what turns a
 // content field that may be a string or a list of blocks into one string, and it is idempotent on a
 // string — so passing its own output back to `has_failure_line` reads exactly as passing the raw
@@ -185,6 +209,7 @@ function to_block(raw: z.infer<typeof BLOCK_SCHEMA>): Block {
 		followup_stages: time_followup_stage.read_stages(text),
 		error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : '',
 		refusal_guard: is_error === true ? guard_from_refusal(text) : '',
+		token_lines: is_error === true ? [] : token_lines_of(text),
 		background_id: time_background.launch_id(text),
 		agent_id: time_background.agent_launch_id(text),
 	}
@@ -248,6 +273,7 @@ function parse_line(line: string): TranscriptLine | undefined {
 const time_transcript_line = {
 	ERROR_TEXT_LIMIT,
 	NO_MESSAGE_ID,
+	TOKEN_LINE_LIMIT,
 	guard_from_refusal,
 	parse_line,
 }

package/scripts/version/npm-registry.ts

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

package/templates/workflows/ci.yml

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

package/.claude/skills/workflow-commands/followup-reference.md

@@ -1,118 +0,0 @@
-# `pnpm josh followup` — the post-execution reference
-
-The parts of the `followup` procedure a run reaches **after** it has issued `pnpm josh followup`: how
-to read the stage-timing block the command prints, the AI-reviewer comment scan and the config-file
-report it runs, and the release ask that closes the completion summary. `followup.md` carries what a
-run needs **before** it issues the command and points here for the rest, so the read that lands in the
-turn that issues `pnpm josh followup` stays small (joshuafolkken/kit#1905).
-
-This file is the single source of the sections below; `followup.md`, `fullrun.md`, `backlogrun.md` and
-`backlogrun.md` point here rather than restating them.
-
-## Reading the stage-timing block
-
-### It prints how long each of those stages took
-
-Since joshuafolkken/kit#1349 the command closes with one row per stage and a total, so "where did
-`followup` spend its time" is read rather than guessed. The shape, with illustrative durations:
-
-```
-followup stage: closes-and-context        2.1 s
-followup stage: checks-wait               28.4 s
-followup stage: coderabbit-comments       1.3 s
-followup stage: ai-review-comments        2.0 s
-followup stage: telegram                  1.1 s
-followup stage: merge                     2.6 s
-followup stage: completion-and-epic-close 1.4 s
-followup stages total:                    38.9 s
-```
-
-- **The block is printed on a failed run too**, up to and including the stage that threw, which is
-  named `interrupted`. A `followup` that exits non-zero on an AI-review blocker or a red check is the
-  invocation whose wait was longest, and one that printed nothing would leave the measurement blind to
-  exactly those. **A short block there is the run stopping early, not the printer breaking**: the
-  stages after the failure never ran, so they have no duration to report.
-- **The `merge` row appears only on a run that merged**, so a `--no-merge` block is a row shorter.
-- **Two rows say `and` because the requests behind them go out together** (joshuafolkken/kit#1446).
-  `closes-and-context` is the former `closes-check` plus `context` — the pull request body, the
-  repository name, the pull request URL and the issue title, four reads that need nothing from one
-  another; `completion-and-epic-close` is the former `completion-comment` plus `epic-close`. A lap
-  records an interval rather than a call, so a batch is one row, and the name is what says which
-  stages it holds. **The one dependency inside the batch is kept**: with no issue number on the
-  command line the title read waits for the body that names it, and only that read waits.
-  **`checks-wait` is untouched**, which is the point — what was overlapped was never a wait.
-- **The total is the sum of the stages, not the command's whole wall clock.** What sits outside it is
-  the tail the workflow script runs afterwards — the review-record clears, the hold
-  release, the next-issue listing and the version line — so a run-timing reading of the same
-  span is longer, and that gap is the tail. It is normally a second or two.
-- **What was measured is on joshuafolkken/kit#1349**, and cutting any of it is deliberately not this
-  block's business: the required-check wait and the AI-review scan are the merge gate, and narrowing
-  either to make a number smaller is the workaround `CLAUDE.md` prohibits.
-
-A `failure` Telegram is sent **by hand, exactly once**, and only when the agent has finally given up
-recovering — never once per retry:
-
-```bash
-pnpm josh notify --task-type failure --issue-url "<issue-url>" --body "<the reason and what is unresolved>"
-```
-
-## AI reviewer comment scan (automatic in `pnpm josh followup`)
-
-`pnpm josh followup` scans top-level PR comments from AI reviewers (Claude Review, CodeRabbit summary comments) **independently of CI status**. This scan runs after CI is green and after the existing CodeRabbit line-comment check. The goal is to ensure substantive findings posted by AI reviewers _after_ CI goes green are not silently shipped.
-
-**Temporary (kit#753)**: while CodeRabbit reviews are slow, CodeRabbit is non-blocking end to end — it is excluded from the default required checks (restore via `JOSH_REQUIRED_CHECKS`), `Actionable comments posted: N` is downgraded to an informational log, and unresolved CodeRabbit line comments no longer require an ignore reason. Every skip is printed to the console and appended to the completion Telegram body. Claude Review blockers are unchanged. Revert together with kit#752.
-
-- Blocker heuristics (conservative, structural — not NLP):
-  - **Claude Review** (`author.login = claude`): body contains `### Issues`, `### Problem`, `#### Logic bug`, or a numbered finding heading like `### 1. ...`
-  - **CodeRabbit** (`author.login = coderabbitai` / `coderabbitai[bot]`): body contains `Actionable comments posted: N` with N > 0. Rate-limit notices (`rate limited by coderabbit.ai` / `Rate limit exceeded`) and "No actionable comments" summaries are ignored.
-- If blockers exist and **no** ignore reason is supplied: `pnpm josh followup` sends a `confirmation` Telegram and exits non-zero. Fix the findings (or provide an ignore reason) and re-run.
-- If blockers exist and `--ai-review-ignore-reason "<reason>"` is supplied: the workflow posts an ignore-reason comment to the PR (mirroring the CodeRabbit ignore-reason flow) and proceeds to completion.
-- Acknowledgment-only Claude comments (`All issues resolved ✓`, `Everything else looks good`) do not match the blocker heuristics, so rounds where the AI reviewer explicitly signs off do not trigger a false positive.
-- **A comment listing that could not be read is treated exactly like a standing blocker.** A rate limit, expired auth, a dropped connection — every one of them used to arrive as an empty listing, so the gate passed without having read anything (joshuafolkken/kit#973). `confirmation` Telegram, non-zero exit, re-run once the read succeeds. `--ai-review-ignore-reason` still gets past it, because what it means is unchanged: a person has looked — and the run then carries an audit note saying the scan was bypassed.
-- **The CodeRabbit line-comment listing is the exception**: unreadable there is reported as an audit note rather than blocking, because kit#753 has CodeRabbit not blocking the merge at all. That reader also answers unreadable when the PR number itself would not resolve, which the top-level scan never has to do. Revert with kit#752.
-
-## Config file reporting (inside `pnpm josh followup`)
-
-**Nothing here asks you to compare anything by eye** (joshuafolkken/kit#1578). `pnpm josh followup` reads the tracked branch diff itself and matches every changed path against everything `josh sync` distributes — the three lists `AI_COPY_FILES`, `AI_COPY_FILE_MAPPINGS`, `AI_COPY_DIRECTORIES`, plus `SYNCED_PATHS`, the destinations `sync` writes directly (`playwright.config.ts`, `eslint.config.js`, the rest).
-
-**It stops nothing** (joshuafolkken/kit#1592). What it produces is a report: the claimed paths and the list that claimed each one go into **the completion notification and the completion report on the Issue**, and the run continues to the CI wait and the merge exactly as a run that distributes nothing does. A run passing `--no-merge` is not reported on, because nothing has been distributed yet.
-
-**It was a confirmation stop until joshuafolkken/kit#1592, and measurement is what removed it rather than preference.** In kit the condition is nearly always true, because kit is the distribution source: every change to `CLAUDE.md`, to `prompts/`, to `.claude/skills/` or to the distributed part of `docs/` is by definition a change to a distributed path. Measured on `epicrun #1413`, **two of three children stopped here** — and in both, the distributed file was the one that child's own acceptance criteria had ordered changed. The gate was not catching an unintended edit; it was stopping the work, and ending unattended execution until a person retyped one command.
-
-**There is deliberately no branch on which repository this is.** Stopping in a consumer project — where editing a distributed file really is the mistake `CLAUDE.md` → "Route distributed-doc / config changes upstream to kit" names, since the next `josh sync` overwrites it silently — while staying quiet in kit was weighed and rejected on joshuafolkken/kit#1592: it needs a distribution-source test this package does not have, no case is recorded of the gate having saved a consumer's work, and the report below reaches a consumer's reader just as well.
-
-**The matching itself is unchanged, and so is the reason it is mechanical.** The instruction the mechanical read replaced was skipped in two runs out of three on the day it was measured, and one of those two could not have succeeded by eye at all: `AI_COPY_DIRECTORIES` holds directories, so a distributed path such as `.claude/skills/workflow-commands/backlogrun.md` appears in no list textually.
-
-```bash
-pnpm josh sync:scope    # managed | clean, naming which list claimed each path
-```
-
-- **There is no flag to pass and nothing to approve.** `--managed-config-ignore-reason` is gone with the stop it existed to get past.
-- This report is produced independently of AI reviewer comment scanning, which still stops the run on a standing blocker
-
-## When `pnpm josh release` runs
-
-**The release point is a position plus a command's answer, never a judgement** (joshuafolkken/kit#1582). joshuafolkken/kit#1169 took the version off the branch and put it behind one command a person types; nothing said *when* to type it, and because nothing fails when nobody does — CI green, every pull request merged, every Issue closed — 53 merges reached main unreleased and no consumer of this package saw one of them.
-
-**The position: once per invocation, after the last merge.** Ask when `pnpm josh followup` has merged the last pull request *this invocation* authorized — a lone `fullrun`'s only one, a `backlogrun`'s **last** child, never once per child. In a lane the parent asks it, in the primary checkout, after the last lane is closed. Asked per child it would cut a release in the middle of a batch whose remaining children are still moving main.
-
-**The answer: `pnpm josh release:scope`.**
-
-```bash
-pnpm josh release:scope          # → required | skip | unknown
-pnpm josh release:scope --json   # the same answer as one JSON object
-```
-
-| It answers | What it means                                                    | What the run does                                                               |
-| ---------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------- |
-| `required` | main has taken at least one merge since the version last changed | Close the completion report with the release request, naming `pnpm josh release` |
-| `skip`     | the count is zero — nothing is waiting to ship                    | Say so in one line and finish                                                     |
-| `unknown`  | the count could not be read                                      | **Report it as `unknown`** — it is never read as `skip`                          |
-
-**The threshold is one, and that is deliberate.** joshuafolkken/kit#1582's own complaint is that accumulating makes a single version larger and its contents harder to trace afterwards, so a release per invocation is the cadence rather than a compromise — and it is the cadence that already held while every child bumped, before joshuafolkken/kit#1486 removed that. What keeps it from firing per child is the position above, not a larger number.
-
-**The run never types `pnpm josh release` itself.** That command opens a pull request of its own, merges it, and starts the tag → publish → `production` chain: outward-facing and effectively irreversible, so it is Tier C (`CLAUDE.md` → "Decision autonomy"). Typing `fullrun` authorizes merging *this Issue's* pull request and nothing past it. On `required` the run reports the request as its closing line and stops there; a person types the command in the primary checkout, on the default branch, with a clean tree.
-
-**`pnpm josh release --dry-run` was checked first and does not answer this.** It refuses off the default branch and on a dirty working tree, and it counts against `HEAD` rather than `origin/<default>` — and every position above is a feature branch or a lane, which is exactly where it throws. So `release:scope` adds **no counting of its own**: it reads `git_followup_pending.read_pending`, the same fetch-then-count `pnpm josh followup` already uses for the Telegram line, and the two therefore cannot disagree.
-
-**This section is the single source.** `fullrun.md`, `backlogrun.md` and `backlogrun.md` point here rather than restating it, and `docs/josh-commands-automation.md` → "`josh release:scope`" documents the command itself.