@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/rules/stop-rules.ts

@@ -1,7 +1,8 @@
 import { hook_decision } from '#scripts/josh/hook-decision'
+import { json_value } from '#scripts/lib/json-value'
 import { z } from 'zod'
+import { concise_reply } from './concise-reply'
 import { filing_offer } from './filing-offer'
-import { issue_citation } from './issue-citation'
 import { lane_background } from './lane-background'
 import { reply_language } from './reply-language'
 import { stop_decision, type StopDecision } from './stop-decision'
@@ -21,7 +22,7 @@ import { stop_decision, type StopDecision } from './stop-decision'
 // `pretool-guard` is one — not a second copy of the plumbing.
 //
 // **A rule whose answer is fixed acts; only a rule that needs judgement refuses** (joshuafolkken/kit#3919).
-// The stop notification, the hold release and the citation lines are each one mechanical operation the
+// The stop notification and the hold release are each one mechanical operation the
 // hook can run itself, so they come back as `actions` and the stop goes through: a refusal is a whole
 // model turn spent re-reading the context to run a command the hook already knew. `stop-actions.ts`
 // runs them, and only an action that fails falls back to its refusal. The rest — the reply's language,
@@ -33,7 +34,7 @@ const SWITCH_ENV_KEY = 'JOSH_STOP_GUARD'
 const BLOCK_DECISION = 'block'
 
 // Only the fields the stop rules read. `last_assistant_message` is the turn's session-facing text —
-// Claude Code hands it directly so the transcript's async lag is never in the citation path.
+// Claude Code hands it directly so the transcript's async lag is never in the rules' path.
 const stop_payload_schema = z.object({
 	transcript_path: z.string().min(1),
 	stop_hook_active: z.boolean().nullish(),
@@ -63,8 +64,8 @@ interface StopContext {
 	notified: boolean
 	// The turn's session-facing reply text.
 	message: string
-	// The person's last prompt — a `#N` it already carried is quoted, not cited.
-	prompt: string
+	// The person's last prompt on the tail — `undefined` when none is on it (`last_prompt.person_prompt`).
+	prompt: string | undefined
 	// This stop already forced a continuation earlier in the prompt — the loop-breaker Claude Code
 	// documents, so a run that will not comply is not blocked forever.
 	stop_hook_active: boolean
@@ -73,7 +74,7 @@ interface StopContext {
 	// the cut holding the tree by design and hands off to a fresh process (`pre-gate-cut.md`), so that
 	// turn-end is an automatic continuation, not the person-waiting pause the block rules are for.
 	cut_pending: boolean
-	// An Issue filing no guard refused is on this run's transcript tail — `filing_cap`'s count.
+	// An Issue filing no guard refused is on this run's transcript tail — `turn_filings`' count.
 	filed: boolean
 	// The owner of the repository the session runs in, or `undefined` when it cannot be read.
 	session_owner: string | undefined
@@ -90,6 +91,9 @@ interface StopContext {
 	// A backgrounded subagent this run launched has not finished — `lane_background.pending_agent_ids`.
 	// Apart from `background_pending`, since only a subagent is sure to end.
 	agent_pending: boolean
+	// A backgrounded command this run launched has not finished — `lane_background.pending_command_ids`.
+	// Apart from `agent_pending`, since the two are waited on differently.
+	command_pending: boolean
 	// This lane child handed its region to a running detached ship — `lane_handoff.is_handed_off`.
 	// The supervisor notifies on its own outcome, so nobody waits on this stop.
 	handed_off: boolean
@@ -107,7 +111,6 @@ interface StopContext {
 type StopAction =
 	| { kind: 'notify'; issue: string; message: string; decision: StopDecision }
 	| { kind: 'release'; issue: string }
-	| { kind: 'cite'; references: ReadonlyArray<string> }
 
 // `reason` refuses the stop; otherwise `actions` run, and `blocks_on_failure` says whether a failed one
 // falls back to its refusal — never past the loop-breaker.
@@ -127,8 +130,8 @@ const STOP_NOTIFY_REASON =
 	'⛔ mid-workflow stop notification: this working tree is still held by a run and no `confirmation` ' +
 	'Telegram was sent this turn. Send ' +
 	'`pnpm josh notify --task-type confirmation --issue-url "<url>" --body=$\'<reason>\' ' +
-	'--recommended "<choice>" --alternative "<choice>"` (`CLAUDE.md` → "Mid-workflow stop ' +
-	'notification"), then confirm in one line that it was sent — do not repeat your previous reply.'
+	'--recommended "<choice>" --alternative "<choice>"` (`rule-delivery.md` → "stop-notify"), ' +
+	'then confirm in one line that it was sent — do not repeat your previous reply.'
 
 // **A clean tree that still holds is a tree the next run will trample.** `working-tree-hold.md`: a stop that
 // leaves the tree clean releases the hold; a `halfrun` pre-commit stop and a `needs-human-review` stop
@@ -140,28 +143,6 @@ const HOLD_RELEASE_REASON =
 	'`working-tree-hold.md`), then confirm in one line that it was released — do not repeat your ' +
 	'previous reply.'
 
-// **The fallback when the hook could not print the citation lines itself**. The bare `#N` is already
-// on screen and the hook cannot unsay it, so the reason does the one thing that helps the *next* reply:
-// it names the numbers it detected and hands over the exact `issue:cite` call that prints the
-// paste-ready lines, then asks for the corrected citation lines alone — not the whole reply reissued.
-// Reprinting the whole reply is what made the correction read as a duplicate;
-// the bare copy already scrolled past stays, and the fix follows it as a short correction. The rule
-// itself is not restated — it is resident in `CLAUDE.md` — only pointed at.
-const ISSUE_CITATION_REASON =
-	'Session-facing output cites an Issue as a number-link so the reader can click through and see ' +
-	'which repository it is (`CLAUDE.md`, `prompts/collaboration-workflow/issue-citation.md`).'
-
-function build_citation_reason(references: ReadonlyArray<string>): string {
-	const numbers = references.join(', ')
-	const command = `pnpm josh issue:cite ${issue_citation.cite_arguments(references).join(' ')}`
-
-	return (
-		`⛔ issue citation: your reply names an Issue as a bare \`#N\` (${numbers}). Run \`${command}\` ` +
-		`to print the paste-ready citation lines, then print the corrected citation lines alone — do not ` +
-		`repeat your previous reply. ${ISSUE_CITATION_REASON}`
-	)
-}
-
 // **An offer to file in an unattended run is a Tier A filing deferred to nobody**.
 // The judgement is already made, so the reason hands over the filing chain rather than a question; the
 // rule itself is resident in `observation-filing.md` and only pointed at. **An interactive session asks
@@ -169,7 +150,7 @@ function build_citation_reason(references: ReadonlyArray<string>): string {
 const FILING_OFFER_REASON =
 	'⛔ filing offer: your reply offers to file an Issue instead of filing it, and this run is ' +
 	'unattended — nobody is there to answer. Run ' +
-	'`pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>` (Tier A, ' +
+	'`pnpm josh issue:file "<title>" --body-file <path>` (Tier A, ' +
 	'`observation-filing.md`), then end with the one-line citation of what was filed; do not repeat ' +
 	'your previous reply. If it is not worth filing after all, say so in one line instead.'
 
@@ -248,6 +229,13 @@ function language_reason(context: StopContext): string | undefined {
 	return build_language_reason(context.session_lang)
 }
 
+// **A reply's narrative over the limit is sent back once to be shortened** — `concise-reply.ts`.
+function concise_reason(context: StopContext): string | undefined {
+	if (!concise_reply.is_over(context.message, context.prompt)) return undefined
+
+	return concise_reply.build_reason(context.message)
+}
+
 // The sessions no person answers: one kit launched under `claude -p` (a lane child, a woken session), a
 // dispatched lane child, or the `backlogrun` parent the user handed the backlog to.
 function is_unattended(context: StopContext): boolean {
@@ -294,24 +282,16 @@ function needs_release(context: StopContext): boolean {
 	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
 }
 
-// The bare references the citation lines are printed for. **A headless agent's reply has no reader**:
-// its text lands in a stream-json log, so correcting its citations or its language costs a turn and
-// reaches nobody. The artifacts a person does read — a Telegram, an Issue, a pull request — are held
-// to the same rules by their own guards, not here.
-function bare_references(context: StopContext): ReadonlyArray<string> {
-	if (context.headless_agent) return []
-
-	return issue_citation.unquoted_references(context.message, context.prompt)
-}
-
-// The two rules that read the reply and need the model, the filing offer first. A drifted reply
+// The rules that read the reply and need the model: the filing offer, then the language, then the
+// length. **A headless agent's reply has no reader**: its text lands in a stream-json log, so
+// correcting its language costs a turn and reaches nobody. A drifted reply
 // refused for another reason is not rewritten, but the drift still ends: `block_envelope` appends the
 // session-language note to every refusal, so the turn it continues is written in the session language.
 function reply_reason(context: StopContext): string | undefined {
 	if (needs_filing(context)) return FILING_OFFER_REASON
 	if (context.headless_agent) return undefined
 
-	return language_reason(context)
+	return language_reason(context) ?? concise_reason(context)
 }
 
 // Sent back once; past the loop-breaker the run has said nothing is awaited, and nothing is sent.
@@ -341,11 +321,19 @@ function needs_background_wait(context: StopContext): boolean {
 	return context.lane_child && context.background_pending
 }
 
+// **Only subagents left take their own wait**: their notice comes in when a tool call ends, while a
+// command is waited on through the detached ship.
+function background_wait_reason(context: StopContext): string {
+	if (context.command_pending) return lane_background.LANE_BACKGROUND_STOP_REASON
+
+	return lane_background.LANE_AGENT_STOP_REASON
+}
+
 // The two lane rules that mean the run is not pausing at all — ahead of every action, since the notify
 // would announce a pause the run has no reason to take.
 function lane_reason(context: StopContext): string | undefined {
 	if (needs_index_route(context)) return LANE_INDEX_REASON
-	if (needs_background_wait(context)) return lane_background.LANE_BACKGROUND_STOP_REASON
+	if (needs_background_wait(context)) return background_wait_reason(context)
 
 	return undefined
 }
@@ -381,14 +369,6 @@ function hold_actions(context: StopContext): Array<StopAction> {
 	return needs_release(context) ? [...notify, { kind: 'release', issue }] : notify
 }
 
-// The actions in the order they run: the notify ahead of the release that ends the hold it reports.
-function stop_actions(context: StopContext): ReadonlyArray<StopAction> {
-	const references = bare_references(context)
-	const cite: Array<StopAction> = references.length > 0 ? [{ kind: 'cite', references }] : []
-
-	return [...hold_actions(context), ...cite]
-}
-
 // First-wins across the refusals. `stop_hook_active` is the loop-breaker, so a run that already got one
 // continuation this prompt may stop; the lane rules go first, then the filing offer, then the language.
 //
@@ -417,7 +397,7 @@ function stop_outcome(context: StopContext): StopOutcome {
 	const reason = block_reason(context)
 	if (!runs_actions(context, reason)) return { ...NO_OUTCOME, reason }
 
-	const actions = stop_actions(context)
+	const actions = hold_actions(context)
 	if (actions.length === 0) return NO_OUTCOME
 
 	return { reason, actions, blocks_on_failure: !context.stop_hook_active }
@@ -425,10 +405,7 @@ function stop_outcome(context: StopContext): StopOutcome {
 
 // The refusal an action falls back to when the hook could not run it.
 function fallback_reason(action: StopAction): string {
-	if (action.kind === 'notify') return STOP_NOTIFY_REASON
-	if (action.kind === 'release') return HOLD_RELEASE_REASON
-
-	return build_citation_reason(action.references)
+	return action.kind === 'notify' ? STOP_NOTIFY_REASON : HOLD_RELEASE_REASON
 }
 
 // The documented shape a `Stop` hook blocks with: `reason` is fed back to Claude, which then continues
@@ -447,9 +424,7 @@ function notice_envelope(notice: string): string {
 }
 
 function parse_stop_payload(raw_payload: string): StopPayload | undefined {
-	const parsed = stop_payload_schema.safeParse(JSON.parse(raw_payload))
-
-	return parsed.success ? parsed.data : undefined
+	return json_value.parse_with(raw_payload, stop_payload_schema)
 }
 
 function is_enabled(): boolean {
@@ -461,7 +436,6 @@ const stop_rules = {
 	HEADLESS_REFUSAL_CAP,
 	HEADLESS_WAIT_REASON,
 	HOLD_RELEASE_REASON,
-	ISSUE_CITATION_REASON,
 	LANE_INDEX_REASON,
 	NO_OUTCOME,
 	STOP_NOTIFY_REASON,

package/scripts/rules/test-declared-commit.ts

@@ -38,7 +38,17 @@ const REASON =
 // The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
 // trigger and reason it already single-sources here. Once per run (the default delivery) for the
 // reason above.
-const ROW = { id: 'test-declared', is_trigger: is_untested_commit, reason: REASON }
+const ROW = {
+	id: 'test-declared',
+	is_trigger: is_untested_commit,
+	reason: REASON,
+	about: {
+		title: 'Test declaration',
+		topic: '`testing-guide.md` → "0. Per-Requirement Test Coverage (MANDATORY)"',
+		fires: '`pnpm josh git -y` (`josh g`) while `pnpm josh test:declared` answers `required`',
+		quiet: '`exempt` (non-runtime only) or `satisfied` (tests included)',
+	},
+}
 
 const test_declared_commit = { REASON, ROW }
 

package/scripts/rules/third-party-write.ts

@@ -1,6 +1,10 @@
 import { repo_party } from '#scripts/discovery/repo-party'
 import { bash_triggers } from './bash-triggers'
 import { gh_api } from './gh-api'
+import { gh_repo_selector } from './gh-repo-selector'
+import { git_argv } from './git-argv'
+import { pr_merge } from './pr-merge'
+import { repo_admin } from './repo-admin'
 import { shell_segments } from './shell-segments'
 
 // The trigger and the delivered text behind the `third-party-write` row of `delivered-rules.ts`.
@@ -70,44 +74,126 @@ function candidates_at(
 	return has_moved ? unreadable_candidates : resolve_placeholder_owners
 }
 
-// The session owner is read only when a segment is actually a `gh api` write to a repository — so an
-// ordinary shell line, and every read, pays nothing for the local config read. `resolve_owner` and
+// A merge or an administration write is refused by its own row whoever owns the target, and one
+// refusal is what a PreToolUse hook carries — so the two readings this row added for
+// joshuafolkken/kit#4659 leave those to the row that names them. Asked only of a candidate, so an
+// ordinary shell line pays nothing for it.
+function is_claimed_by_narrower_row(command: string): boolean {
+	return pr_merge.is_pr_merge(command) || repo_admin.is_repo_admin_write(command)
+}
+
+// **A GraphQL mutation names no repository this guard can read** (joshuafolkken/kit#4659): its target
+// is a node id inside the body, so it is refused whoever owns the session — the disposition
+// `pr-merge.ts` takes for a GraphQL body it cannot read, which that row already refuses for a body
+// read from a file or computed by the shell. A query passes. The keyword is looked for in the whole
+// line, because the segment cut ignores quotes and a multi-line query splits across it. A query field
+// the shell expands (`query="$Q"`, or the whole argument quoted: `"query=$Q"`) hides its keyword the
+// same way, so it is refused as a mutation; a single-quoted `query='query($o: String!) {…}'` is
+// literal and still read. A body read from a file is `pr-merge.ts`'s, which refuses it already.
+const GRAPHQL_MUTATION = /\bmutation\b/u
+const EXPANDED_QUERY = /^(?:-[fF])?"?query=(?!')[\s\S]*\$/u
+
+function is_hidden_or_mutation(command: string, args: ReadonlyArray<string>): boolean {
+	return GRAPHQL_MUTATION.test(command) || args.some((argument) => EXPANDED_QUERY.test(argument))
+}
+
+// The arguments of a `gh api` GraphQL call, or `undefined` when the segment is not one.
+function graphql_args(segment: string): ReadonlyArray<string> | undefined {
+	const call = git_argv.program_of(segment)
+
+	if (call === undefined || !gh_api.is_gh_api(segment)) return undefined
+
+	return pr_merge.is_graphql_call(call.name, call.args) ? call.args : undefined
+}
+
+function is_graphql_mutation(command: string, segment: string): boolean {
+	const args = graphql_args(segment)
+
+	if (args === undefined) return false
+
+	return is_hidden_or_mutation(command, args) && !is_claimed_by_narrower_row(command)
+}
+
+// **A `gh <group> <action> -R <owner>/<repo>` write is judged by its selector** (kit#4659).
+// A selector whose owner cannot be read (`-R "$REPO"`) is refused, like an unreadable placeholder
+// candidate: it is a repository `gh` really writes to.
+function is_third_party_selector_write(
+	command: string,
+	segments: ReadonlyArray<string>,
+	index: number,
+	session_owner: string | undefined,
+): boolean {
+	const selectors = gh_repo_selector.write_selectors(segments, index)
+	const is_third_party = selectors.some((selector) => {
+		const owner = repo_party.selector_owner(selector)
+
+		return (
+			owner === undefined || repo_party.classify(session_owner, owner) === repo_party.THIRD_PARTY
+		)
+	})
+
+	return is_third_party && !is_claimed_by_narrower_row(command)
+}
+
+function is_owner_dependent_write(segments: ReadonlyArray<string>, index: number): boolean {
+	const segment = segments[index] ?? ''
+
+	if (gh_api.is_gh_api(segment)) return gh_api.is_write(segment)
+
+	return gh_repo_selector.write_selectors(segments, index).length > 0
+}
+
+function writes_to_third_party_owner(
+	command: string,
+	segments: ReadonlyArray<string>,
+	resolve_owner: () => string | undefined,
+	resolve_placeholder_owners: () => Array<string | undefined>,
+): boolean {
+	if (segments.every((_segment, index) => !is_owner_dependent_write(segments, index))) return false
+
+	const session_owner = resolve_owner()
+
+	return segments.some(
+		(segment, index) =>
+			is_third_party_selector_write(command, segments, index, session_owner) ||
+			is_third_party_write_segment(
+				segment,
+				session_owner,
+				candidates_at(segments, index, resolve_placeholder_owners),
+			),
+	)
+}
+
+// The session owner is read only when a segment is actually a repository write — so an ordinary shell
+// line, and every read, pays nothing for the local config read. `resolve_owner` and
 // `resolve_placeholder_owners` are injected so the suite fixes the owners without touching the real
 // remotes, the way `file-body.ts` injects `has_file`. Each segment is judged on its own, so a `gh api`
 // write quoted inside another command's argument is read as the write it is not, exactly as every
-// other trigger here reads its own.
+// other trigger here reads its own. The cut is by program — a pipe and a background `&` cut too, a
+// quoted one does not — after joining backslash-continued lines, so `echo hi | gh pr comment …` and a
+// `gh api graphql \⏎ -f query=…` are each read as the one `gh` call they launch.
 function writes_third_party(
 	command: string,
 	resolve_owner: () => string | undefined = repo_party.current_owner,
 	resolve_placeholder_owners: () => Array<string | undefined> = repo_party.placeholder_owners,
 ): boolean {
-	const segments = shell_segments.segments_of(command)
-	const has_write = segments.some(
-		(segment) => gh_api.is_gh_api(segment) && gh_api.is_write(segment),
+	const segments = shell_segments.quote_aware_commands_of(
+		shell_segments.joined_continuations(command),
 	)
 
-	if (!has_write) return false
-
-	const session_owner = resolve_owner()
+	if (segments.some((segment) => is_graphql_mutation(command, segment))) return true
 
-	return segments.some((segment, index) =>
-		is_third_party_write_segment(
-			segment,
-			session_owner,
-			candidates_at(segments, index, resolve_placeholder_owners),
-		),
-	)
+	return writes_to_third_party_owner(command, segments, resolve_owner, resolve_placeholder_owners)
 }
 
 // The instruction in the shape a refusal can carry: what the command does, why it is Tier C, and what
 // to do instead. The command that computes the party is handed over, because the whole point of this
 // Issue is that the test is computed rather than judged.
 const THIRD_PARTY_WRITE_REASON =
-	'⛔ third-party write: this `gh api` call writes to a repository whose owner is not this session, ' +
-	'which is Tier C and needs explicit current-turn user instruction. Check with ' +
-	'`pnpm josh repo:party <owner/repo>`, then record the finding on our own Issue and draft the ' +
-	'artifact for a person to post. This rule fires on every occurrence ' +
-	'(`prompts/collaboration-workflow/upstream-interrupt.md`).'
+	"⛔ third-party write: this `gh` call writes to another owner's repository, or one it cannot " +
+	'read (a GraphQL mutation, an unreadable `-R`) — Tier C. Check `pnpm josh repo:party ' +
+	'<owner/repo>`; first-party, use a REST `repos/<owner>/<repo>` path. Else record it on our ' +
+	'Issue and draft it for a person to post. Fires on every occurrence (`upstream-interrupt.md`).'
 
 // `decide` returns true so it refuses every occurrence; it declares no `keeps` — not writing to
 // another owner's tracker is the absence of a call, not a call, so the row is reported unmeasured
@@ -117,6 +203,14 @@ const ROW = {
 	is_trigger: bash_triggers.on_bash_command((command: string) => writes_third_party(command)),
 	reason: THIRD_PARTY_WRITE_REASON,
 	decide: (): boolean => true,
+	about: {
+		title: 'Third-party write',
+		topic: '`upstream-interrupt.md`',
+		fires:
+			'a `gh api` write (field flag or a write method) or a `gh <group> <action>` write selected by `-R` / `GH_REPO` to a repository whose owner is not this session, or a `gh api graphql` call whose line names `mutation` or whose query the shell expands, outside the merge and administration rows. Every occurrence',
+		quiet:
+			'a read, a GraphQL query, or a first-party owner (pinned at session start, `pnpm josh repo:party`)',
+	},
 }
 
 const third_party_write = {

package/scripts/rules/timed-rerun.ts

@@ -0,0 +1,69 @@
+import { bash_triggers } from './bash-triggers'
+import { shell_segments } from './shell-segments'
+
+// The trigger and the delivered text behind the `timed-rerun` row of `delivered-rules.ts`
+// (joshuafolkken/kit#4356). A lane agent timed a whole-tree `eslint` twice to learn what CI already
+// records, and each run took about 1.3 cores for seven minutes outside the core budget.
+//
+// **The timer is the trigger, not the tool.** What a run is after when it prefixes `time` or reaches
+// for `hyperfine` is a duration, and a duration of CI or of the gate is already on record — the Actions
+// jobs and the lane ledger. The tool under the timer can be anything, so reading the timer is the one
+// trigger that does not have to enumerate them.
+//
+// **Once per run.** The rule allows one re-run when the record cannot answer, so the reissue goes
+// through. On that reissue `lane-direct-tool` still refuses a lane child's `time`-prefixed heavy tool
+// (`git_argv` skips the timer), never wrapping it, and points it at `pnpm josh reserved-run`, the overlap
+// `delivered-rules.ts` admits. A `hyperfine "<command>"` carries the tool inside a quoted argument,
+// which `lane-direct-tool` does not read, so in a lane that reissue is not budgeted.
+
+// A segment that opens with a timer, behind any environment assignments: `time`, `/usr/bin/time -p`
+// and `hyperfine`. Anchored at the segment start, so a quoted mention or an argument is not a timer.
+const TIMED_SEGMENT = /^\s*(?:[A-Za-z_]\w*=\S*\s+)*(?:\S*\/)?(?:time|hyperfine)\s/u
+
+function is_timed_run(command: string): boolean {
+	return shell_segments
+		.quote_aware_commands_of(command)
+		.some((segment) => TIMED_SEGMENT.test(segment))
+}
+
+// Reading the record: an Actions run or job listing, or the lane ledger's gate timings.
+const RECORD_READ = /\bgh\s+api\b.*\/actions\/runs\b|\bjosh\s+(?:lane:stats|lst)\b/u
+
+function reads_the_record(command: string): boolean {
+	return RECORD_READ.test(command)
+}
+
+function measures_duration(command: string): boolean {
+	return reads_the_record(command) || is_timed_run(command)
+}
+
+const TIMED_RERUN_REASON =
+	'⛔ timed re-run: a CI or gate duration is already on record — read the Actions jobs with ' +
+	'`gh api …/actions/runs/<run_id>/jobs` or the gate timings with `pnpm josh lane:stats`. Re-run ' +
+	'only when the record cannot answer: reissue the same command once, and post the result on the ' +
+	'Issue (`prompts/collaboration-workflow/measurement.md`).'
+
+// The row itself, so `delivered-rules.ts` spreads one entry; once per run, so the one allowed re-run
+// goes through on the reissue.
+const ROW = {
+	id: 'timed-rerun',
+	is_trigger: bash_triggers.on_bash_command(is_timed_run),
+	reason: TIMED_RERUN_REASON,
+	keeps: bash_triggers.on_bash_command(reads_the_record),
+	reaches: bash_triggers.on_bash_command(measures_duration),
+	about: {
+		title: 'Timed re-run',
+		topic: '`measurement.md`',
+		fires: 'a command timed with `time` / `/usr/bin/time` / `hyperfine`',
+		quiet: 'the duration is read from the Actions jobs or `pnpm josh lane:stats`',
+	},
+}
+
+const timed_rerun = {
+	ROW,
+	TIMED_RERUN_REASON,
+	is_timed_run,
+	reads_the_record,
+}
+
+export { timed_rerun }

package/scripts/rules/turn-filings.ts

@@ -0,0 +1,90 @@
+import { time_shell } from '#scripts/time-runtime/time-shell'
+import { time_transcript_line, type Block } from '#scripts/time-runtime/time-transcript-line'
+import { bash_triggers } from './bash-triggers'
+import { tail_commands } from './tail-commands'
+
+// The filings a turn made, read off the session transcript for the `Stop` hook's offer to file
+// (`stop-guard.ts`). **No new predicate**: the filing is `bash_triggers.is_issue_filing`, reused
+// verbatim. The filing cap is not this count — it is `issue:file`'s own step, per originating work item
+// (`scripts/issue/issue-file-cap.ts`, joshuafolkken/kit#4750).
+//
+// **A guard-refused filing does not count.** Claude Code writes a denied call to the transcript as a
+// `tool_use` block with an errored `tool_result` — the same exclusion `investigation-reads.ts` makes
+// for a refused read. **Nor does one `issue:file` held itself**: a lint problem or an unacknowledged
+// duplicate exits non-zero having filed nothing. The filing is counted only where its result did not
+// fail.
+
+interface TailFilings {
+	// The `tool_use` id of every filing on the tail.
+	filing_ids: Array<string>
+	// The id of every result that came back as a failure — a guard refusal, or `issue:file` holding the
+	// filing itself (a lint problem, an unacknowledged duplicate), which files nothing either.
+	failures: Set<string>
+}
+
+function is_filing_use(block: Block): boolean {
+	if (!tail_commands.is_bash_use(block)) return false
+
+	return bash_triggers.is_issue_filing(time_shell.bash_command(block.input))
+}
+
+function collect_block(block: Block, found: TailFilings): void {
+	if (block.result_id !== '' && block.is_error === true) found.failures.add(block.result_id)
+	if (is_filing_use(block)) found.filing_ids.push(block.id)
+}
+
+function collect_line(line: string, found: TailFilings): void {
+	const parsed = time_transcript_line.parse_line(line)
+
+	if (parsed === undefined) return
+
+	for (const block of parsed.blocks) collect_block(block, found)
+}
+
+function scan_tail(tail: string): TailFilings {
+	const found: TailFilings = { filing_ids: [], failures: new Set<string>() }
+
+	for (const line of tail.split('\n')) collect_line(line, found)
+
+	return found
+}
+
+// How many Issues the tail filed, counting only filings whose result did not fail.
+function filing_count(tail: string): number {
+	const { filing_ids, failures } = scan_tail(tail)
+
+	return filing_ids.filter((id) => !failures.has(id)).length
+}
+
+// A person's prompt: a `user` line carrying no tool result. Tool results ride `user` lines too, so the
+// absence of one is what marks the line as typed rather than returned.
+function is_prompt_line(line: string): boolean {
+	const parsed = time_transcript_line.parse_line(line)
+
+	if (parsed?.type !== 'user') return false
+
+	return parsed.blocks.every((block) => block.result_id === '')
+}
+
+// The tail from the last prompt on, so a filing an earlier turn made does not answer for this one.
+// A tail with no prompt on it is returned whole.
+function current_turn(tail: string): string {
+	const lines = tail.split('\n')
+	const start = lines.findLastIndex((line) => is_prompt_line(line))
+
+	return lines.slice(Math.max(start, 0)).join('\n')
+}
+
+// How many Issues this turn has filed — `filing_count` read over `current_turn`.
+function turn_filing_count(tail: string): number {
+	return filing_count(current_turn(tail))
+}
+
+const turn_filings = {
+	current_turn,
+	filing_count,
+	is_prompt_line,
+	turn_filing_count,
+}
+
+export { turn_filings }