@joshuafolkken/kit 1.1453.0 → 1.1471.0

package/scripts/lane/lane-spent.ts

@@ -178,10 +178,13 @@ function issues_traced(traced: ReadonlyArray<TracedLane>, trace: ProcessTrace):
 	return traced.filter(([, answer]) => answer === trace).map(([issue]) => issue)
 }
 
+function traced_of(lanes: ReadonlyArray<LaneInfo>, probes: SpentProbes): Array<TracedLane> {
+	return lanes.map((lane): TracedLane => [lane.issue, trace_of(lane, probes)])
+}
+
 /** The lanes in use — what a run being replaced must not be stopped over. */
 async function lanes_in_use(probes: SpentProbes = LIVE_PROBES): Promise<LaneUse> {
-	const lanes = await lane_registry.list_lanes()
-	const traced = lanes.map((lane): TracedLane => [lane.issue, trace_of(lane, probes)])
+	const traced = traced_of(await lane_registry.list_lanes(), probes)
 
 	return {
 		working: issues_traced(traced, PROCESS_ALIVE),
@@ -189,7 +192,15 @@ async function lanes_in_use(probes: SpentProbes = LIVE_PROBES): Promise<LaneUse>
 	}
 }
 
-const lane_spent = { kept_reason, lanes_in_use, sort_lanes }
+/** The lanes no child is working in, read as such — never one whose probe did not answer. */
+function idle_lanes(
+	lanes: ReadonlyArray<LaneInfo>,
+	probes: SpentProbes = LIVE_PROBES,
+): Array<string> {
+	return issues_traced(traced_of(lanes, probes), PROCESS_NONE)
+}
+
+const lane_spent = { idle_lanes, kept_reason, lanes_in_use, sort_lanes }
 
 export type { KeptLane, LaneUse, SpentProbes, SpentSort }
 export { lane_spent }

package/scripts/lane/lane-stats.ts

@@ -258,6 +258,7 @@ const lane_stats = {
 	MISSING,
 	header,
 	in_window,
+	mean,
 	median,
 	peak,
 	row,

package/scripts/managed-marker/managed-marker-logic.ts

@@ -46,8 +46,7 @@ function apply_marker_for_destination(
 	text: string,
 	package_name: string,
 ): string {
-	if (!is_workflow_destination(destination)) return text
-	if (is_marked(text)) return text
+	if (!is_workflow_destination(destination) || is_marked(text)) return text
 
 	return `${marker_block(package_name)}${text}`
 }

package/scripts/notify/confirmation-options.ts

@@ -0,0 +1,59 @@
+import { session_language } from '#scripts/josh/session-language'
+
+// **A confirmation names what to choose, not only why the run stopped.** The person reading it is
+// off-screen by definition, so the message itself carries the recommended choice and the others —
+// in the session language, because that is the language the person works in.
+
+interface ConfirmationOptions {
+	recommended: string
+	alternatives: ReadonlyArray<string>
+}
+
+interface Headings {
+	recommended: string
+	alternatives: string
+	none: string
+}
+
+const JAPANESE_LANG_PREFIX = 'ja'
+const JAPANESE_HEADINGS: Headings = {
+	recommended: '推奨:',
+	alternatives: '他の選択肢:',
+	none: 'なし',
+}
+const ENGLISH_HEADINGS: Headings = {
+	recommended: 'Recommended:',
+	alternatives: 'Alternatives:',
+	none: 'none',
+}
+
+// Only the two languages the workflow is written in have headings; any other falls back to English.
+function headings(): Headings {
+	const { lang } = session_language.resolve_session_lang()
+
+	return lang.toLowerCase().startsWith(JAPANESE_LANG_PREFIX) ? JAPANESE_HEADINGS : ENGLISH_HEADINGS
+}
+
+// An empty list is stated as none, so a confirmation with no other option says so rather than
+// leaving a reader to wonder whether the line was lost.
+function alternatives_block(options: ConfirmationOptions, labels: Headings): string {
+	if (options.alternatives.length === 0) return `${labels.alternatives} ${labels.none}`
+
+	const lines = options.alternatives.map((alternative) => `- ${alternative}`)
+
+	return [labels.alternatives, ...lines].join('\n')
+}
+
+// The block is handed to the sender as its own `choices` field rather than appended to the body:
+// the body is what a too-long message is cut from, and the choices are the one part a reader cannot
+// act without, so they must survive the cut.
+function block(options: ConfirmationOptions): string {
+	const labels = headings()
+
+	return `${labels.recommended} ${options.recommended}\n${alternatives_block(options, labels)}`
+}
+
+const confirmation_options = { block }
+
+export { confirmation_options }
+export type { ConfirmationOptions }

package/scripts/notify/notify-opt-in.ts

@@ -0,0 +1,33 @@
+import type { TelegramTaskType } from './telegram-notify'
+
+// **`planning` and `completion` reach a person only when they asked for them.** Neither needs the
+// person to act now — a plan is posted on the Issue and a merge is visible on the pull request — so
+// sending both on every run buried the types that do need someone. Every other type is unaffected.
+//
+// **One variable listing the opted-in types, not one switch per type**, so making a further type
+// optional later adds an entry to `OPTIONAL_TASK_TYPES` rather than another variable.
+const OPT_IN_KEY = 'JOSH_NOTIFY_OPT_IN'
+const OPTIONAL_TASK_TYPES: ReadonlySet<TelegramTaskType> = new Set(['planning', 'completion'])
+const LIST_SEPARATOR = ','
+
+function opted_in_types(): ReadonlyArray<string> {
+	return (process.env[OPT_IN_KEY] ?? '')
+		.split(LIST_SEPARATOR)
+		.map((entry) => entry.trim().toLowerCase())
+		.filter((entry) => entry.length > 0)
+}
+
+// Unset means none: an optional type is sent only once it is named.
+function is_skipped(task_type: TelegramTaskType): boolean {
+	if (!OPTIONAL_TASK_TYPES.has(task_type)) return false
+
+	return !opted_in_types().includes(task_type)
+}
+
+function skip_line(task_type: TelegramTaskType): string {
+	return `🔕 ${task_type} notifications are not opted in (${OPT_IN_KEY}).`
+}
+
+const notify_opt_in = { is_skipped, skip_line }
+
+export { notify_opt_in }

package/scripts/notify/telegram-notify.ts

@@ -1,6 +1,8 @@
 import { gh_spawn } from '#scripts/gh/gh-spawn'
 import { timed_fetch } from '#scripts/lib/timed-fetch'
 import { z } from 'zod'
+import { confirmation_options, type ConfirmationOptions } from './confirmation-options'
+import { notify_opt_in } from './notify-opt-in'
 
 const TELEGRAM_API_BASE = 'https://api.telegram.org'
 // `sendMessage` refuses a text longer than this.
@@ -42,6 +44,9 @@ interface TelegramSendInput {
 	repo_name: string | undefined
 	issue_title: string | undefined
 	body: string | undefined
+	// A confirmation's recommended choice and the others — set beside the body rather than inside it
+	// so a body cut to the length limit never takes the choices with it.
+	choices?: string | undefined
 	issue_url: string | undefined
 	pr_url: string | undefined
 }
@@ -149,6 +154,16 @@ function is_notify_disabled(): boolean {
 	return parse_environment_string(process.env[NOTIFY_SWITCH_KEY]).toLowerCase() === NOTIFY_OFF_VALUE
 }
 
+// The line a skipped send prints, or `undefined` for a send that goes out. The blanket opt-out wins
+// over the per-type opt-in, so `off` stays the one switch that silences everything.
+function skip_line(task_type: TelegramTaskType): string | undefined {
+	if (is_notify_disabled()) {
+		return `🔕 Telegram notifications are disabled (${NOTIFY_SWITCH_KEY}=${NOTIFY_OFF_VALUE}).`
+	}
+
+	return notify_opt_in.is_skipped(task_type) ? notify_opt_in.skip_line(task_type) : undefined
+}
+
 function build_header(task_type: TelegramTaskType, repo_name: string | undefined): string {
 	const { icon, label } = TASK_DEFINITIONS[task_type]
 	if (repo_name === undefined || repo_name.length === 0) return `${icon} ${label}`
@@ -185,6 +200,7 @@ function build_blocks(input: TelegramSendInput): Array<string> {
 	const blocks: Array<string> = [build_title_block(input)]
 
 	push_if_present(blocks, input.body)
+	push_if_present(blocks, input.choices)
 	blocks.push(...build_url_parts(input))
 
 	return blocks
@@ -243,13 +259,13 @@ function build_send_failure(error: unknown, config: TelegramConfig): Error {
 //
 // The failure it throws carries a `cause`, and that cause is redacted too — see `build_send_failure`.
 //
-// The opt-out is checked here, before `load_config`, so every caller — the tolerant form included —
-// skips the same way and none has to repeat the check.
+// The opt-out and the per-type opt-in are checked here, before `load_config`, so every caller — the
+// tolerant form included — skips the same way and none has to repeat the check.
 async function send(input: TelegramSendInput): Promise<void> {
-	if (is_notify_disabled()) {
-		console.info(
-			`🔕 Telegram notifications are disabled (${NOTIFY_SWITCH_KEY}=${NOTIFY_OFF_VALUE}).`,
-		)
+	const skipped = skip_line(input.task_type)
+
+	if (skipped !== undefined) {
+		console.info(skipped)
 
 		return
 	}
@@ -341,7 +357,7 @@ async function warn(input: WarningInput): Promise<boolean> {
 	)
 }
 
-interface ConfirmInput {
+interface ConfirmInput extends ConfirmationOptions {
 	issue_title: string
 	body: string
 	recovery: string
@@ -365,6 +381,7 @@ async function confirm(input: ConfirmInput): Promise<boolean> {
 			repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
 			issue_title: input.issue_title,
 			body: input.body,
+			choices: confirmation_options.block(input),
 			issue_url: undefined,
 			pr_url: undefined,
 		},
@@ -463,4 +480,4 @@ const telegram_notify = {
 }
 
 export { telegram_notify, build_text, TASK_DEFINITIONS, telegram_environment_schema }
-export type { TelegramSendInput, TelegramTaskType }
+export type { ConfirmInput, TelegramSendInput, TelegramTaskType }

package/scripts/notify/telegram-test-logic.ts

@@ -1,4 +1,5 @@
 import { cli_body } from '#scripts/josh/cli-body'
+import { confirmation_options } from './confirmation-options'
 import type { TelegramSendInput, TelegramTaskType } from './telegram-notify'
 
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -10,6 +11,8 @@ interface CliValues {
 	'body-file'?: string
 	'issue-url'?: string
 	'pr-url'?: string
+	recommended?: string
+	alternative?: Array<string>
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
@@ -67,12 +70,41 @@ function normalize_body(values: CliValues): string | undefined {
 	})
 }
 
+// **A confirmation without a recommended choice is refused, not sent**: the person it reaches is
+// off-screen, and a stop that names no choice leaves them to reconstruct one. `--alternative` may be
+// absent — a stop with one way forward says so — so only `--recommended` is required.
+function require_recommended(values: CliValues): string {
+	const recommended = values.recommended?.trim() ?? ''
+
+	if (recommended.length === 0) {
+		throw new Error('--task-type confirmation needs --recommended "<the recommended choice>".')
+	}
+
+	return recommended
+}
+
+function given_alternatives(values: CliValues): Array<string> {
+	return (values.alternative ?? []).filter((alternative) => alternative.trim().length > 0)
+}
+
+function build_choices(values: CliValues, task_type: TelegramTaskType): string | undefined {
+	if (task_type !== 'confirmation') return undefined
+
+	return confirmation_options.block({
+		recommended: require_recommended(values),
+		alternatives: given_alternatives(values),
+	})
+}
+
 function build_input(input: { values: CliValues; context: ResolvedContext }): TelegramSendInput {
+	const task_type = parse_task_type(input.values['task-type'])
+
 	return {
-		task_type: parse_task_type(input.values['task-type']),
+		task_type,
 		repo_name: coalesce(input.values['repo-name'], input.context.repo_name),
 		issue_title: coalesce(input.values['issue-title'], input.context.issue_title),
 		body: normalize_body(input.values),
+		choices: build_choices(input.values, task_type),
 		issue_url: input.values['issue-url'],
 		pr_url: input.values['pr-url'],
 	}

package/scripts/notify/telegram-test.ts

@@ -14,10 +14,10 @@ const REPO_NAME_SEPARATOR = '/'
 const ARGV_OFFSET = 2
 const FAILURE_EXIT_CODE = 1
 const USAGE =
-	'Usage: josh notify [--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>]'
+	'Usage: josh notify [--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...'
 
 // The free-text values a caller writes, often opening with a Markdown `-` bullet.
-const FREE_TEXT_FLAGS = ['--body', '--issue-title']
+const FREE_TEXT_FLAGS = ['--body', '--issue-title', '--recommended', '--alternative']
 
 const OPTIONS = {
 	'task-type': { type: 'string' },
@@ -27,6 +27,8 @@ const OPTIONS = {
 	'body-file': { type: 'string' },
 	'issue-url': { type: 'string' },
 	'pr-url': { type: 'string' },
+	recommended: { type: 'string' },
+	alternative: { type: 'string', multiple: true },
 } as const
 
 // `undefined` for a line nobody can read — an unknown flag, or a flag given no value.

package/scripts/overrides/lockfile-overrides.ts

@@ -42,9 +42,7 @@ function find_entry_mismatch(
 	specifier: string,
 	override: string | undefined,
 ): Array<SpecifierMismatch> {
-	if (override === undefined) return []
-	if (is_non_registry(specifier)) return []
-	if (specifier === override) return []
+	if (override === undefined || specifier === override || is_non_registry(specifier)) return []
 
 	return [{ importer, name, lockfile_specifier: specifier, override }]
 }

package/scripts/propagate/propagate.ts

@@ -277,8 +277,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	}
 
 	const plan = plan_run(options)
-	if (plan === undefined) return FAILURE_EXIT_CODE
-	if (!(await resolve_publish(plan, options))) return FAILURE_EXIT_CODE
+	if (plan === undefined || !(await resolve_publish(plan, options))) return FAILURE_EXIT_CODE
 
 	return propagate_to_consumers(plan, options.is_dry_run)
 }

package/scripts/release/release-progress.ts

@@ -145,8 +145,9 @@ async function wait_for_github_release(version: string): Promise<boolean> {
 async function wait_for_distribution(version: string): Promise<number> {
 	const manifest = read_manifest(process.cwd())
 
-	if (!(await wait_for_npm(manifest, version))) return FAILURE_EXIT_CODE
-	if (!(await wait_for_github_release(version))) return FAILURE_EXIT_CODE
+	if (!(await wait_for_npm(manifest, version)) || !(await wait_for_github_release(version))) {
+		return FAILURE_EXIT_CODE
+	}
 
 	console.info(complete_line(version))
 

package/scripts/report/report-lint.ts

@@ -102,8 +102,7 @@ function overview_lines(summary: string): ReadonlyArray<string> {
 function item_sentence(line: string): string {
 	const open = line.indexOf(BOLD_MARKER)
 	const close = open === -1 ? -1 : line.indexOf(BOLD_MARKER, open + BOLD_MARKER.length)
-	const raw =
-		close === -1 ? line.slice(ITEM_LINE_PREFIX.length) : line.slice(close + BOLD_MARKER.length)
+	const raw = line.slice(close === -1 ? ITEM_LINE_PREFIX.length : close + BOLD_MARKER.length)
 
 	return raw.replace(LEADING_LABEL_PUNCTUATION, '').trim()
 }
@@ -199,8 +198,12 @@ function break_condition_count(lines: ReadonlyArray<string>): number {
 }
 
 function case_line_violations(summary: string): ReadonlyArray<string> {
-	if (!has_changes_section(summary)) return []
-	if (changes_region_lines(summary).some((line) => line.includes(CASE_LABEL))) return []
+	if (
+		!has_changes_section(summary) ||
+		changes_region_lines(summary).some((line) => line.includes(CASE_LABEL))
+	) {
+		return []
+	}
 
 	return [`✖ no case tier (${CASE_LABEL}:) in ${CHANGES_LABEL}`]
 }

package/scripts/review/review-record-cli.ts

@@ -58,8 +58,12 @@ interface Parsed {
 // A finding spec is `<category>:<severity>:<file>`; the file field keeps any `:line` a citation
 // carries, so only the first two colons separate fields.
 function to_finding(category: string, severity: string, file: string): Finding | undefined {
-	if (!review_finding_ledger.is_category(category)) return undefined
-	if (!review_finding_ledger.is_severity(severity)) return undefined
+	if (
+		!review_finding_ledger.is_category(category) ||
+		!review_finding_ledger.is_severity(severity)
+	) {
+		return undefined
+	}
 
 	return review_finding_ledger.is_valid_file(file) ? { category, severity, file } : undefined
 }

package/scripts/rules/destructive-command.ts

@@ -97,21 +97,18 @@ function is_destructive_command(command: string): boolean {
 }
 
 const DESTRUCTIVE_COMMAND_REASON =
-	'⛔ destructive command: a recursive forced `rm` (`rm -rf`, `rm -fr`, `rm -r -f`, `rm --recursive ' +
-	'--force`), `gh repo delete` / `archive`, `gh repo edit --visibility`, `gh pr close`, or a `gh api ' +
-	'-X DELETE repos/…` call deletes or closes something that cannot be restored, which is Tier C and ' +
-	'needs explicit current-turn user instruction (`prompts/collaboration-workflow/operating-rules.md`). ' +
-	'The `.claude/settings.json` deny list matches prefix globs, so it misses these spellings; this row ' +
-	'reads the argv instead. Remove a file or directory one path at a time without `-f`, or ask the user ' +
-	'to run the command in their own terminal. `gh issue close` and removing a label from an Issue ' +
-	'(`DELETE repos/<o>/<r>/issues/<N>/labels/<name>`) are not refused. **This rule fires on every ' +
-	'occurrence, not once per run.**'
+	'⛔ destructive command: a recursive forced `rm`, a `gh repo delete` / `archive` / visibility edit, ' +
+	'`gh pr close` or a `gh api -X DELETE` cannot be undone, which is Tier C. Remove one path at a ' +
+	'time without `-f`, or ask the user to run it. It fires on every occurrence ' +
+	'(`prompts/collaboration-workflow/operating-rules.md`).'
 
 const ROW = {
 	id: 'destructive-command',
 	is_trigger: bash_triggers.on_bash_command(is_destructive_command),
 	reason: DESTRUCTIVE_COMMAND_REASON,
 	decide: (): boolean => true,
+	// The opening the reason carried before it was cut to the action and the next command.
+	former_reasons: ['⛔ destructive command: a recursive forced `rm` (`rm -rf`'],
 }
 
 const destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW, is_destructive_command }

package/scripts/rules/direct-filing.ts

@@ -9,13 +9,9 @@ import { bash_triggers } from './bash-triggers'
 
 const DIRECT_FILING_REASON =
 	'⛔ direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> ' +
-	'--depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api …/issues` ' +
-	'or `gh issue create`. The command runs every filing step in order — the duplicate scout, the body ' +
-	'lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing ' +
-	'into another repository, and `epic:bundle` after the create — so none of them is a step to remember. ' +
-	'When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,…>` ' +
-	'for the ones that are separate deliverables. Reference: `docs/josh-commands-backlog.md` → "`josh issue:file`". ' +
-	'**This rule fires on every occurrence, not once per run.**'
+	'--depth <0|1|2>`, never with `gh api …/issues` or `gh issue create` — it runs the scout, the lint, ' +
+	'the labels and `epic:bundle` itself. It fires on every occurrence (`docs/josh-commands-backlog.md` ' +
+	'→ "`josh issue:file`").'
 
 function is_any_filing(command: string): boolean {
 	return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command)

package/scripts/rules/early-heartbeat.ts

@@ -178,25 +178,14 @@ function decide(call: GuardedCall, run: GuardRun, can_record: boolean): boolean
 }
 
 // The instruction in the shape a refusal can carry: what the call is about to do, what already does it
-// properly, and the one command an explicit ask is answered with. The observed failure is named
-// because it is what makes the rule believable.
+// properly, and the one command an explicit ask is answered with. The observed failure behind it is in
+// `docs/maintainers/rule-delivery-rationale.md`.
 const EARLY_HEARTBEAT_REASON =
-	'⛔ early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours ' +
-	'to keep. `pnpm josh run:progress --wait` keeps it for you ' +
-	'(`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, ' +
-	'default 20 minutes): start it once in the background and it reports the five labelled lines to ' +
-	"the run's event stream on its own, without waking you — relay nothing, and start it again only " +
-	'after it exits, which it does when newly runnable work arrives. Two timers armed at ' +
-	'once is what produced reports 3–5 minutes apart on a 15-minute setting ' +
-	'(joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a ' +
-	"child's completion woke the run, and `--mark` recorded each report without anything refusing the " +
-	'early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run ' +
-	'`pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says — ' +
-	'under `backlogrun`, `pnpm josh run:board --chat` instead. If you are ' +
-	'waiting on something rather than on a clock, wait on the thing itself — `pnpm josh followup` ' +
-	'waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` → "Progress while ' +
-	'the run is quiet". **This rule fires on every early arm, not once per run**, so reissuing the ' +
-	'same sleep will be refused again.'
+	'⛔ early heartbeat: this call arms a wait timer of its own. Start `pnpm josh run:progress --wait` ' +
+	"once in the background: it reports to the run's event stream on its own — relay nothing. When " +
+	'asked, `pnpm josh run:progress --once` — under `backlogrun`, `pnpm josh run:board --chat`; ' +
+	'for CI, `pnpm josh followup`. It fires on every occurrence ' +
+	'(`.claude/skills/workflow-commands/progress-watcher.md`).'
 
 // **Keeping this rule is letting the watcher hold the clock** — `pnpm josh run:progress --wait` waits
 // the interval out, and `--once` answers an explicit ask. `--mark` is neither: it records a report

package/scripts/rules/file-body.ts

@@ -171,20 +171,13 @@ function carries_a_file_body(
 	)
 }
 
-// The instruction in the shape a refusal can carry: what the command is doing, the safe tool, and the
-// file forms that stay allowed. The measured cost is named because it is the half that reads as
-// surprising — the command body is billed on every later request of the run.
+// The instruction in the shape a refusal can carry: what the command is doing and the safe tool. The
+// measured cost behind it is in `file-edits.md`.
 const FILE_BODY_REASON =
-	"⛔ file body in a shell command: this carries a file's new text inline — a heredoc rewriting an " +
-	'existing file, an interpreter (`python3 - <<`, `node -e`) whose body writes, a script file (`cat > ' +
-	'edit.py <<EOF`) whose body writes, or an in-place `perl -0pi -e`. `CLAUDE.md` forbids it because ' +
-	'the command body is re-read on every later request of the run, so an editing script written early ' +
-	'is billed for the rest of it (`file-edits.md` measured one run at ~2m45s spent retyping existing ' +
-	'lines). Edit a region with the Edit tool (old / new); a change scattered so widely that the ' +
-	'partial edits would carry more than the file is rewritten whole with the Write tool, never a ' +
-	'heredoc. Pass a body by path (`--field body=@<path>`, `--body-file <path>`). A new-file creation (`cat > ' +
-	'<new-file> <<EOF`), a read-only heredoc (`cat <<EOF`), and a short `sed -i` stay allowed. **This ' +
-	'rule fires on every occurrence, not once per run.**'
+	"⛔ file body in a shell command: this carries a file's new text inline, which is re-read on every " +
+	'later request. Edit a region with the Edit tool, rewrite a whole file with the Write tool, and ' +
+	'pass a body by path (`--body-file <path>`); a new-file `cat > <new-file> <<EOF` stays allowed. ' +
+	'This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).'
 
 const ROW = {
 	id: 'file-body',

package/scripts/rules/filing-cap.ts

@@ -104,12 +104,9 @@ function decide(_call: unknown, run: GuardRun): boolean {
 }
 
 const FILING_CAP_REASON =
-	`⛔ filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling — on ` +
-	'reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot ' +
-	'manufacture Issues faster than they can be closed (`.claude/skills/workflow-commands/SKILL.md` → ' +
-	"`prerequisite.md`, `observation-filing.md`). A further Issue that genuinely must exist is a person's call, not " +
-	"this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the " +
-	'same filing will be refused again.'
+	`⛔ filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop ` +
+	"filing and report; a further Issue is a person's call. It fires on every occurrence " +
+	'(`.claude/skills/workflow-commands/observation-filing.md`).'
 
 // The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
 // trigger and reason it already single-sources here. It declares no `keeps`: staying under a cap is

package/scripts/rules/git-force.ts

@@ -69,19 +69,15 @@ function is_force_or_delete(command: string): boolean {
 	return shell_segments.segments_of(command).some((segment) => is_destructive_segment(segment))
 }
 
-// The instruction in the shape a refusal can carry: what the command does, why the deny list did not
-// stop it, and the one route left. There is no "safe reissue" the way a backgrounded push is for
+// The instruction in the shape a refusal can carry: what the command does and the one route left. The
+// spellings the deny glob misses are pinned on `is_force_or_delete`, not repeated in the text. There is no "safe reissue" the way a backgrounded push is for
 // `run-tail` — a force push and a branch delete are Tier C, so the honest next move is a person's, in
 // their own terminal.
 const GIT_FORCE_REASON =
 	'⛔ force push or branch delete: this rewrites or removes shared history, which is Tier C and needs ' +
-	'explicit current-turn user instruction — never an AI decision, even to fix a problem you caused ' +
-	'(`prompts/collaboration-workflow/operating-rules.md`). The `.claude/settings.json` deny list ' +
-	'matches globs, so it misses this spelling: a combined short cluster (`git push -uf`), a `git -C ' +
-	'<path>` prefix, and the colon-form delete (`git push origin :branch`) all pass it. This row reads ' +
-	'the argv instead, so the spelling does not matter. For an ordinary push use `pnpm josh git`; a ' +
-	"force push, a `git push --delete` / `:branch`, or a `git branch -d` / `-D` is the user's to run in " +
-	'their own terminal. **This rule fires on every occurrence, not once per run.**'
+	'explicit current-turn user instruction. Push with `pnpm josh git`; leave a force push or branch ' +
+	"delete to the user's own terminal. This rule fires on every occurrence " +
+	'(`prompts/collaboration-workflow/operating-rules.md`).'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `decide` returns true so it refuses every
 // occurrence; it declares no `keeps` — not force-pushing is the absence of a call, not a call, so the