@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/rules/stop-rules.ts

@@ -1,9 +1,11 @@
 import { hook_decision } from '#scripts/josh/hook-decision'
+import { json_value } from '#scripts/lib/json-value'
 import { z } from 'zod'
 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'
 
 // The stop-time rules, delivered on the `Stop` hook.
 //
@@ -19,11 +21,14 @@ import { reply_language } from './reply-language'
 // permission envelope. The stop guard is a second *entry* on the one foundation, exactly as
 // `pretool-guard` is one — not a second copy of the plumbing.
 //
-// **Every rule refuses**. Missing the stop notification or leaving a hold
-// on a clean tree costs a person a silent wait or a trampled tree; a bare `#N` in the reply reaches
-// the person watching but not the model that could fix it, so it too blocks — `{"decision":"block"}`
-// is the one channel a `Stop` hook has to the model, and `stop_hook_active` caps a false positive at a
-// single wasted turn. The detection is tightened to match (`issue-citation.ts`, `filing-offer.ts`).
+// **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
+// 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,
+// an unattended filing offer, a lane's index request or running task, a headless parent's wait — need
+// the model, so they still block with `{"decision":"block"}`, the one channel a `Stop` hook has to it;
+// `stop_hook_active` caps a false positive at a single wasted turn.
 
 const SWITCH_ENV_KEY = 'JOSH_STOP_GUARD'
 const BLOCK_DECISION = 'block'
@@ -40,14 +45,22 @@ type StopPayload = z.infer<typeof stop_payload_schema>
 
 // What one stop looks like to the rules, computed once by the CLI from the payload and the world.
 interface StopContext {
-	// The `run:hold` record for this working tree is still in place (`held` or `stale`).
-	hold_present: boolean
+	// The Issue the `run:hold` record for this working tree names (`held` or `stale`) — `new` for an
+	// unnumbered entry — or `undefined` when no record is in place.
+	hold_issue: string | undefined
+	// That record is this session's own run's, or its owner cannot be told (`run-hold-session.ts`). A
+	// hold another run took is that run's pause to announce and release, never this session's.
+	hold_owned: boolean
+	// The person opened this turn with a question: the reply answers someone at the session, not a
+	// pause waiting on them (`stop-decision.ts` → `is_question`).
+	answers_question: boolean
 	// `git status --porcelain` came back empty.
 	tree_clean: boolean
 	// That record carries a `prrun` stop mark: the run stopped at a green pull
 	// request and keeps the hold over a clean tree on purpose, so a person can look before it merges.
 	prrun_stopped: boolean
-	// A `confirmation` notify is on this run's transcript tail.
+	// A `confirmation` notify is on this run's transcript tail, or the hook's own send is recorded on the
+	// hold since the pause began (`run-hold-session.ts` → `is_notified_since`).
 	notified: boolean
 	// The turn's session-facing reply text.
 	message: string
@@ -56,7 +69,8 @@ interface StopContext {
 	// 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
-	// A pre-gate cut record is in place for this work tree. A dispatched lane child ends its turn at
+	// This turn ended at a cut — its record is in place, or this turn relaunched the successor that may
+	// already have cleared it (`stop-guard.ts` → `is_cut_stop`). A dispatched lane child ends its turn at
 	// 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
@@ -90,15 +104,26 @@ interface StopContext {
 	backlog_parent: boolean
 }
 
+// The operations the hook runs itself instead of refusing — each carries what it acts on.
+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.
 interface StopOutcome {
 	reason: string | undefined
+	actions: ReadonlyArray<StopAction>
+	blocks_on_failure: boolean
 }
 
-const NO_OUTCOME: StopOutcome = { reason: undefined }
+const NO_OUTCOME: StopOutcome = { reason: undefined, actions: [], blocks_on_failure: false }
 
 // **A mid-workflow stop is announced off-screen before it happens.** `CLAUDE.md` → "Mid-workflow stop
 // notification" requires the `confirmation` Telegram before any pause; the hold is what says a run is
-// mid-workflow, and the transcript is what says the notify was sent.
+// mid-workflow, and the transcript is what says the notify was sent. The hook sends it; this reason is
+// only the fallback for a send that failed.
 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 ' +
@@ -109,13 +134,14 @@ const STOP_NOTIFY_REASON =
 // **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
 // keep it because their tree is dirty, which is why this row is silent whenever the tree is not clean.
+// The hook releases it; this reason is only the fallback for a release that failed.
 const HOLD_RELEASE_REASON =
 	'⛔ working-tree hold not released: this working tree is clean but its `run:hold` record is still in ' +
 	'place. Release it with `pnpm josh run:release <N>` (bare for a `new` entry; ' +
 	'`working-tree-hold.md`), then confirm in one line that it was released — do not repeat your ' +
 	'previous reply.'
 
-// **A refusal that corrects rather than advises**. The bare `#N` is already
+// **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.
@@ -144,7 +170,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.'
 
@@ -246,42 +272,52 @@ function needs_filing(context: StopContext): boolean {
 //
 // **A lane handed to the detached ship stands them down too**: the hold now
 // belongs to the supervisor driving the merge, and the person hears from that supervisor's own notify.
+//
+// **Another run's hold stands them down as well**: the pause and the claim are that run's.
 function is_held_idle(context: StopContext): boolean {
-	return context.hold_present && !context.agent_pending && !context.handed_off
+	if (context.hold_issue === undefined || !context.hold_owned) return false
+
+	return !context.agent_pending && !context.handed_off
 }
 
+// **A stop that answers the person's question is no pause** (joshuafolkken/kit#3961): they are reading
+// the reply where it was written, whatever the tree's hold says.
 function needs_notify(context: StopContext): boolean {
-	return is_held_idle(context) && !context.notified
+	return is_held_idle(context) && !context.notified && !context.answers_question
 }
 
-function needs_release(context: StopContext): boolean {
-	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
+// The notify a stop owes but cannot send: its reply names no decision to announce.
+function needs_decision(context: StopContext): boolean {
+	return needs_notify(context) && stop_decision.decision_of(context.message) === undefined
 }
 
-function citation_reason(context: StopContext): string | undefined {
-	const references = issue_citation.unquoted_references(context.message, context.prompt)
-	if (references.length === 0) return undefined
-
-	return build_citation_reason(references)
+function needs_release(context: StopContext): boolean {
+	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
 }
 
-// The two rules on how a reply is written. **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 wording_reason(context: StopContext): string | undefined {
-	if (context.headless_agent) return undefined
+// 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 citation_reason(context) ?? language_reason(context)
+	return issue_citation.unquoted_references(context.message, context.prompt)
 }
 
-// The three rules that read the reply itself, filing offer first and the language last. A drifted reply
+// The two rules that read the reply and need the model, the filing offer first. 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 wording_reason(context)
+	return language_reason(context)
+}
+
+// Sent back once; past the loop-breaker the run has said nothing is awaited, and nothing is sent.
+function decision_reason(context: StopContext): string | undefined {
+	return needs_decision(context) ? stop_decision.DECISION_REASON : undefined
 }
 
 // The headless wait holds past the loop-breaker until the spin bound is reached.
@@ -306,24 +342,56 @@ function needs_background_wait(context: StopContext): boolean {
 	return context.lane_child && context.background_pending
 }
 
-// The two hold rules, notify ahead of release — behind the lane index route
-// and the lane background wait, since the notify they would ask for announces
-// a pause the run has no reason to take.
-function hold_reason(context: StopContext): string | undefined {
+// 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_notify(context)) return STOP_NOTIFY_REASON
-	if (needs_release(context)) return HOLD_RELEASE_REASON
 
 	return undefined
 }
 
-// First-wins across every rule. Two things stand every rule down: `stop_hook_active` (the
-// loop-breaker, so a run that already got one continuation this prompt may stop) and a pre-gate cut in
-// flight (a lane child's automatic turn-end, not a person-waiting pause). The two hold rules keep their
-// order ahead of the reply rules, so a stop that both still owes its notify and holds a bare `#N` still
-// reports the notify first; the filing offer goes ahead of the citation, since the filing it forces
-// produces the citation the reply then needs.
+// The refusals that need the model: the lane rules alone, else the reply's own and the decision
+// together. **Joined, since the loop-breaker grants one continuation**: a decision refusal queued behind
+// a language or filing refusal would never be sent, and its stop would pass with no notify.
+function model_reason(context: StopContext): string | undefined {
+	const lane = lane_reason(context)
+	if (lane !== undefined) return lane
+
+	const reasons = [reply_reason(context), decision_reason(context)].filter(
+		(reason) => reason !== undefined,
+	)
+
+	return reasons.length === 0 ? undefined : reasons.join('\n\n')
+}
+
+// The notify carries the reply's own decision; a reply with none sends nothing (`needs_decision`).
+function notify_actions(context: StopContext, issue: string): Array<StopAction> {
+	const decision = stop_decision.decision_of(context.message)
+	if (decision === undefined || !needs_notify(context)) return []
+
+	return [{ kind: 'notify', issue, message: context.message, decision }]
+}
+
+function hold_actions(context: StopContext): Array<StopAction> {
+	const issue = context.hold_issue
+	if (issue === undefined) return []
+
+	const notify = notify_actions(context, issue)
+
+	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.
 //
 // **The headless wait comes first and outlasts `stop_hook_active` up to its spin bound**.
 // The loop-breaker exists so a person is not wedged behind a rule the run will not satisfy; a headless
@@ -334,24 +402,53 @@ function block_reason(context: StopContext): string | undefined {
 	if (is_headless_held(context)) return HEADLESS_WAIT_REASON
 	if (context.stop_hook_active || context.cut_pending) return undefined
 
-	return hold_reason(context) ?? reply_reason(context)
+	return model_reason(context)
+}
+
+// **The actions run only on the stop that goes through**, so a refused stop never notifies a pause its
+// continuation then cancels, while the continuation's own stop, past the loop-breaker, still runs them
+// and a failure there no longer refuses. A lane child still waiting on its own work runs none, and a
+// pre-gate cut in flight stands everything but the headless wait down: it is a lane child's automatic
+// turn-end, not a person-waiting pause.
+function runs_actions(context: StopContext, reason: string | undefined): boolean {
+	return reason === undefined && !context.cut_pending && lane_reason(context) === undefined
 }
 
 function stop_outcome(context: StopContext): StopOutcome {
-	return { reason: block_reason(context) }
+	const reason = block_reason(context)
+	if (!runs_actions(context, reason)) return { ...NO_OUTCOME, reason }
+
+	const actions = stop_actions(context)
+	if (actions.length === 0) return NO_OUTCOME
+
+	return { reason, actions, blocks_on_failure: !context.stop_hook_active }
+}
+
+// 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)
 }
 
 // The documented shape a `Stop` hook blocks with: `reason` is fed back to Claude, which then continues
 // instead of stopping. Plain stdout is not it — only this envelope holds the stop. Every reason leaves
 // with the session-language note, so no rule can hand the model an English-only turn.
-function block_envelope(reason: string, lang: string): string {
-	return JSON.stringify({ decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` })
+// `notice` is what the hook already did on this stop, shown to the person alongside.
+function block_envelope(reason: string, lang: string, notice?: string): string {
+	const refusal = { decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` }
+
+	return JSON.stringify(notice === undefined ? refusal : { ...refusal, systemMessage: notice })
 }
 
-function parse_stop_payload(raw_payload: string): StopPayload | undefined {
-	const parsed = stop_payload_schema.safeParse(JSON.parse(raw_payload))
+// The shape a `Stop` hook shows the person a line in without holding the stop: `systemMessage` alone.
+function notice_envelope(notice: string): string {
+	return JSON.stringify({ systemMessage: notice })
+}
 
-	return parsed.success ? parsed.data : undefined
+function parse_stop_payload(raw_payload: string): StopPayload | undefined {
+	return json_value.parse_with(raw_payload, stop_payload_schema)
 }
 
 function is_enabled(): boolean {
@@ -371,10 +468,12 @@ const stop_rules = {
 	block_envelope,
 	build_language_reason,
 	count_headless_refusals,
+	fallback_reason,
 	is_enabled,
+	notice_envelope,
 	parse_stop_payload,
 	stop_outcome,
 }
 
-export type { StopContext, StopOutcome }
+export type { StopAction, StopContext, StopOutcome }
 export { stop_rules }

package/scripts/rules/tail-commands.ts

@@ -30,6 +30,20 @@ function prior_bash_commands(tail: string): ReadonlyArray<string> {
 	return tail.split('\n').flatMap((line) => bash_commands_of(line))
 }
 
-const tail_commands = { is_bash_use, prior_bash_commands }
+// **Whether a call `is_call` names answered with the `token` line** — the call and its own result
+// paired off parsed blocks, so a transcript that merely quotes the command or the token does not
+// count. An unreadable text reads as no answer.
+function answered(text: string, is_call: (command: string) => boolean, token: string): boolean {
+	const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks)
+	const call_ids = new Set(
+		blocks
+			.filter((block) => is_call(time_shell.bash_command(block.input)))
+			.map((block) => block.id),
+	)
+
+	return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token))
+}
+
+const tail_commands = { answered, is_bash_use, prior_bash_commands }
 
 export { tail_commands }

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: '`CLAUDE.md` → Code Change Rules',
+		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

@@ -117,6 +117,13 @@ 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) to a repository whose owner is not this session. Every occurrence',
+		quiet: 'a read, or a first-party owner (`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) 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/worktree-guard.ts

@@ -17,7 +17,9 @@ import { shell_segments } from './shell-segments'
 // that stash findable and poppable by `pnpm josh stash:pop`, which is the whole of `operating-rules.md`'s
 // safety argument; the forms it warns against are the *positional/bare* ones. So `git stash push -m`
 // (with or without `-u`) and the read-only `git stash list` / `show` pass, and everything else — bare
-// `git stash`, a message-less push, `pop` / `apply` / `drop` / `save` / `clear` — is refused.
+// `git stash`, a message-less push, `pop` / `apply` / `drop` / `save` / `clear` — is refused. Those
+// flows now push with `pnpm josh stash:push` (joshuafolkken/kit#4131), invisible here; the raw message
+// form still passes for a procedure written before it.
 //
 // **The refusal names the way on for a handed-over stash.** joshuafolkken/kit#3630's plan restored a
 // stash with `git stash apply`, and the lane parked on how to apply it instead of popping by message;
@@ -117,7 +119,7 @@ function is_unauthorized_segment(segment: string): boolean {
 }
 
 function is_unauthorized_worktree_change(command: string): boolean {
-	return shell_segments.segments_of(command).some((segment) => is_unauthorized_segment(segment))
+	return shell_segments.commands_of(command).some((segment) => is_unauthorized_segment(segment))
 }
 
 // The instruction in the shape a refusal can carry: what the command touches, the authorized route,
@@ -125,7 +127,7 @@ function is_unauthorized_worktree_change(command: string): boolean {
 // invisible to this trigger, so a run that uses them is never refused.
 const WORKTREE_MUTATION_REASON =
 	'⛔ unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, ' +
-	'`git stash`. A documented flow stashes with `git stash push -u -m "<message>"`; a handed-over ' +
+	'`git stash`. A documented flow stashes with `pnpm josh stash:push "<message>"`; a handed-over ' +
 	'stash is `pnpm josh stash:pop "<message>"`; record the substitution on the Issue (Tier A) unless ' +
 	'the plan says why the owner keeps the stash: then stop and confirm. It fires on every occurrence ' +
 	'(`operating-rules.md`).'
@@ -135,6 +137,14 @@ const ROW = {
 	is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
 	reason: WORKTREE_MUTATION_REASON,
 	decide: (): boolean => true,
+	about: {
+		title: 'Unauthorized work-tree mutation',
+		topic: '`operating-rules.md`',
+		fires:
+			'`git checkout -- <path>` / `git restore <path>` / forced `git clean -f` / an unauthorized `git stash` (bare, push without a message, positional pop). Every occurrence',
+		quiet:
+			'`git stash push -m`, `git stash list`, `pnpm josh git`, `pnpm josh stash:push`, `pnpm josh stash:pop`',
+	},
 }
 
 const worktree_guard = {

package/scripts/run/board/run-board-app-name.ts

@@ -0,0 +1,23 @@
+import path from 'node:path'
+
+// The name an app is drawn under on `run:board`'s 💻 processes section, computed from its command.
+// `run-board-process-groups.ts` remembers each command's answer, so a redraw names only the processes
+// new since the last one (joshuafolkken/kit#4263).
+
+const APP_SUFFIX = '.app'
+const COMMAND_SEPARATOR = ' '
+
+// An app's name: the outermost `.app` bundle its executable sits in, else its command's own name.
+function app_of(command: string): string {
+	const bundle = command.split(path.sep).find((part) => part.endsWith(APP_SUFFIX))
+
+	if (bundle !== undefined) return bundle.slice(0, -APP_SUFFIX.length)
+
+	const executable = command.startsWith(path.sep) ? command : command.split(COMMAND_SEPARATOR)[0]
+
+	return path.basename(executable ?? command)
+}
+
+const run_board_app_name = { app_of }
+
+export { run_board_app_name }