@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/scripts/release/release-publish-run.ts

@@ -1,13 +1,22 @@
 import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
 import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { json_value } from '#scripts/lib/json-value'
-import { github_release_runs, type RunSource } from './github-release-runs'
+import { github_release_runs, type JobOutcomes, type RunSource } from './github-release-runs'
 import { release_tag } from './release-tag'
 
 // The tag's Publish run as `pnpm josh release` sees it through `gh`, so the npm wait can end the
 // moment that run fails instead of waiting out its timeout for a version that will never appear.
 
 const PUBLISH_WORKFLOW = 'publish.yml'
+const NPM_JOBS = ['publish-npm']
+
+// `has_npm_job_failed` holds unless `publish-npm` succeeded — so also when the jobs could not be
+// read, since nothing then shows that npm took the version.
+interface FailedRun {
+	run_id: number
+	failed_jobs: ReadonlyArray<string>
+	has_npm_job_failed: boolean
+}
 
 function gh_run_source(): RunSource {
 	return {
@@ -21,19 +30,43 @@ function gh_run_source(): RunSource {
 	}
 }
 
+async function read_job_outcomes(source: RunSource, run_id: number): Promise<JobOutcomes> {
+	try {
+		return await github_release_runs.job_outcomes(source, run_id)
+	} catch {
+		return { failed: [], succeeded: [] }
+	}
+}
+
+// Only a `publish-npm` that succeeded clears npm: one skipped because `pack` failed never publishes.
+async function describe_failure(source: RunSource, run_id: number): Promise<FailedRun> {
+	const { failed, succeeded } = await read_job_outcomes(source, run_id)
+	const has_npm_job_failed = succeeded.every(
+		(name) => !github_release_runs.is_named_job(name, NPM_JOBS),
+	)
+
+	return { run_id, failed_jobs: failed, has_npm_job_failed }
+}
+
 // A repository without the workflow, or a read that fails, tells nothing about the run, so the npm
 // wait goes on as it did before the run was asked about.
-async function failed_run_id(version: string): Promise<number | undefined> {
+async function failed_run(version: string): Promise<FailedRun | undefined> {
 	try {
-		const tag = release_tag.tag_name(version)
-		const run = await github_release_runs.publish_run(gh_run_source(), PUBLISH_WORKFLOW, tag)
+		const source = gh_run_source()
+		const run = await github_release_runs.publish_run(
+			source,
+			PUBLISH_WORKFLOW,
+			release_tag.tag_name(version),
+		)
+		if (!run || github_release_runs.run_state(run) !== 'failed') return undefined
 
-		return run && github_release_runs.run_state(run) === 'failed' ? run.id : undefined
+		return await describe_failure(source, run.id)
 	} catch {
 		return undefined
 	}
 }
 
-const release_publish_run = { failed_run_id }
+const release_publish_run = { failed_run }
 
+export type { FailedRun }
 export { release_publish_run }

package/scripts/repo/repository-labels.ts

@@ -31,10 +31,13 @@ function read_existing(repo: string): ReadonlyArray<string> | undefined {
 	return listing?.split('\n').filter((name) => name.length > 0)
 }
 
-function missing_labels(existing: ReadonlyArray<string>): ReadonlyArray<LabelDefinition> {
+function missing_labels(
+	existing: ReadonlyArray<string>,
+	wanted: ReadonlyArray<LabelDefinition>,
+): ReadonlyArray<LabelDefinition> {
 	const names = new Set(existing.map((name) => name.toLowerCase()))
 
-	return REPOSITORY_LABELS.filter((label) => !names.has(label.name.toLowerCase()))
+	return wanted.filter((label) => !names.has(label.name.toLowerCase()))
 }
 
 function create_label(label: LabelDefinition, repo: string): boolean {
@@ -52,9 +55,11 @@ function label_names(labels: ReadonlyArray<LabelDefinition>): ReadonlyArray<stri
 
 // An unreadable listing is not an empty one: nothing is created, and every label is reported as
 // unconfirmed rather than as missing. An unresolved repository (no GitHub remote) is the same case.
-function unreadable(repo: string | undefined = 'this repository'): ReadonlyArray<string> {
-	const names = label_names(REPOSITORY_LABELS)
-	const target = repo
+function unreadable(
+	wanted: ReadonlyArray<LabelDefinition>,
+	target = 'this repository',
+): ReadonlyArray<string> {
+	const names = label_names(wanted)
 
 	console.warn(
 		`  ⚠ could not read the labels of ${target}; make sure these exist: ${names.join(', ')}`,
@@ -76,14 +81,19 @@ function create_missing(
 	return names
 }
 
-// The label names not confirmed present afterwards — empty when the repository has every one.
-function ensure_labels(repo: string | undefined): ReadonlyArray<string> {
-	if (repo === undefined) return unreadable(repo)
+// The label names not confirmed present afterwards — empty when the repository has every one. `extra`
+// adds labels outside kit's set (an Issue's `worker:<name>`) to the same single listing read.
+function ensure_labels(
+	repo: string | undefined,
+	extra: ReadonlyArray<LabelDefinition> = [],
+): ReadonlyArray<string> {
+	const wanted = [...REPOSITORY_LABELS, ...extra]
+	if (repo === undefined) return unreadable(wanted)
 
 	const existing = read_existing(repo)
-	if (existing === undefined) return unreadable(repo)
+	if (existing === undefined) return unreadable(wanted, repo)
 
-	return create_missing(missing_labels(existing), repo)
+	return create_missing(missing_labels(existing, wanted), repo)
 }
 
 // The label names `ensure_labels` would create, read without creating any — every one when the
@@ -93,7 +103,9 @@ function planned_labels(repo: string | undefined): ReadonlyArray<string> | undef
 	if (repo === undefined) return label_names(REPOSITORY_LABELS)
 	const existing = read_existing(repo)
 
-	return existing === undefined ? undefined : label_names(missing_labels(existing))
+	return existing === undefined
+		? undefined
+		: label_names(missing_labels(existing, REPOSITORY_LABELS))
 }
 
 const repository_labels = { ensure_labels, planned_labels }

package/scripts/review/review-comment-round.ts

@@ -5,6 +5,8 @@ import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
 import { parse_json, parse_json_array_safe } from '#scripts/git/parse-json-array'
 import { session_cite } from '#scripts/issue/session-cite'
+import { CARRIED_ROUNDS_SUFFIX } from '#scripts/observations/observation-ledger'
+import { observation_ledger_archive } from '#scripts/observations/observation-ledger-archive'
 import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
 import { observation_ledger_line } from '#scripts/observations/observation-ledger-line'
 import { z } from 'zod'
@@ -37,8 +39,7 @@ const COMMENT_NOTE =
 	'Kept here rather than in the observation ledger: a line appended after the commit would be pushed onto the open pull request and restart its CI.'
 const CODE_FENCE = '```'
 const OBSERVATION_LINE_MARK = '- k:'
-const CARRIED_SUFFIX = '-comment-rounds'
-const CARRIED_FILE_PATTERN = new RegExp(String.raw`^\d+${CARRIED_SUFFIX}\.md$`, 'u')
+const CARRIED_FILE_PATTERN = new RegExp(String.raw`^\d+${CARRIED_ROUNDS_SUFFIX}\.md$`, 'u')
 // One page of the newest closed issues: an issue leaves the search's interest once carried, so the
 // ones still to carry are the recently closed.
 const PER_PAGE = '100'
@@ -145,7 +146,7 @@ async function closed_issues(): Promise<ReadonlyArray<number>> {
 }
 
 function carried_path(issue: number, root: string): string {
-	return observation_ledger_home.file_path(`${String(issue)}${CARRIED_SUFFIX}`, root)
+	return observation_ledger_home.file_path(`${String(issue)}${CARRIED_ROUNDS_SUFFIX}`, root)
 }
 
 // A path this carry writes, told by its file name alone so a git status path answers it too.
@@ -173,10 +174,14 @@ async function carry_issue(issue: number, root: string): Promise<number> {
 	return lines.length
 }
 
-// Copies every closed issue's comment rounds not yet in the ledger, and answers how many lines.
+// Copies every closed issue's comment rounds not yet in the ledger, and answers how many lines. A
+// rounds file the archive moved is carried as well (`observation-ledger-archive.ts`).
 async function carry(root: string): Promise<number> {
 	const issues = await closed_issues()
-	const pending = issues.filter((issue) => !existsSync(carried_path(issue, root)))
+	const archived = observation_ledger_archive.archived_rounds(root)
+	const pending = issues.filter(
+		(issue) => !archived.has(issue) && !existsSync(carried_path(issue, root)),
+	)
 	const counts = await Promise.all(pending.map(async (issue) => await carry_issue(issue, root)))
 
 	return counts.reduce((total, count) => total + count, 0)

package/scripts/rules/broad-investigation-shell.ts

@@ -2,6 +2,7 @@ import { readFileSync, statSync } from 'node:fs'
 import path from 'node:path'
 import { time_josh_names } from '#scripts/time-runtime/time-josh-names'
 import { shell_segments } from './shell-segments'
+import { shell_tokens } from './shell-tokens'
 
 // Which shell commands are broad investigation (joshuafolkken/kit#5351): a search over a tree, a
 // read past the line cap, an aggregation script. A narrow check — a bounded range of one file, a
@@ -19,7 +20,6 @@ const LINE_COUNT_PREFIXES = ['--lines=', '-n', '-']
 const DIGITS = /^\d+$/u
 const FROM_LINE = /^\+\d+$/u
 const QUOTES = /^['"]|['"]$/gu
-const WHITESPACE = /\s+/u
 const ASSIGNMENT = /^\w+=/u
 const ALWAYS_BROAD: ReadonlySet<string> = new Set(['find', 'for', 'node', 'python', 'python3'])
 const ANALYSIS_PREFIX = 'josh cost:'
@@ -139,7 +139,7 @@ const COMMAND_TESTS: ReadonlyMap<string, CommandTest> = new Map([
 ])
 
 function words_of(segment: string): Array<string> {
-	const words = segment.split(WHITESPACE).map((word) => word.replaceAll(QUOTES, ''))
+	const words = shell_tokens.words_of(segment).map((word) => word.text.replaceAll(QUOTES, ''))
 	const start = words.findIndex((word) => !ASSIGNMENT.test(word))
 
 	return start === -1 ? [] : words.slice(start)

package/scripts/rules/codex-prompt.ts

@@ -0,0 +1,63 @@
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// Native desktop rollouts mark each content item's provenance. A user role alone also
+// carries AGENTS/environment context, so only user-authored items become prompts (#7399).
+const content_schema = z.array(
+	z.object({
+		type: z.string(),
+		text: z.string().optional(),
+	}),
+)
+const provenance_schema = z.object({ provenance: z.object({ type: z.string() }) })
+const metadata_schema = z.object({ content_item_metadata: z.array(provenance_schema) })
+const payload_schema = z.object({
+	type: z.literal('message'),
+	role: z.enum(['user', 'assistant']),
+	content: content_schema,
+	internal_chat_message_metadata_passthrough: metadata_schema.optional(),
+})
+const record_schema = z.object({
+	type: z.literal('response_item'),
+	timestamp: z.string(),
+	payload: payload_schema,
+})
+
+function content_text(block: z.infer<typeof content_schema>[number]): string {
+	if (block.type !== 'input_text' && block.type !== 'output_text') return ''
+
+	return block.text ?? ''
+}
+
+function person_content(payload: z.infer<typeof record_schema>['payload']): string | undefined {
+	const metadata = payload.internal_chat_message_metadata_passthrough?.content_item_metadata
+	if (metadata?.length !== payload.content.length) return undefined
+
+	const authored = payload.content
+		.filter((_block, index) => metadata[index]?.provenance.type === 'user')
+		.map((block) => content_text(block))
+
+	return authored.length === 0 ? undefined : authored.join('\n')
+}
+
+// Preserve user turn boundaries while marking unproven content as harness-authored.
+function normalize(line: string): string {
+	const record = json_value.parse_with(line, record_schema)
+	if (record === undefined) return line
+	const { payload, timestamp } = record
+	const content =
+		payload.role === 'user'
+			? person_content(payload)
+			: payload.content.map((block) => content_text(block)).join('\n')
+
+	return JSON.stringify({
+		type: payload.role,
+		timestamp,
+		...(content === undefined && { origin: { kind: 'harness' } }),
+		message: { content: content ?? '' },
+	})
+}
+
+const codex_prompt = { normalize }
+
+export { codex_prompt }

package/scripts/rules/direct-issue-comment.ts

@@ -1,11 +1,14 @@
+import path from 'node:path'
 import type { RepoIdentity } from '#scripts/discovery/repo-origin'
 import { repo_party } from '#scripts/discovery/repo-party'
 import type { HookContext } from '#scripts/hooks/hook-context'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { bash_triggers } from './bash-triggers'
 import { direct_pr_create } from './direct-pr-create'
 import { gh_api } from './gh-api'
 import { git_argv } from './git-argv'
 import { shell_segments } from './shell-segments'
+import { standalone_gh_call, type StandaloneCall } from './standalone-gh-call'
 
 // The `direct-issue-comment` row of `delivered-rules.ts`. A run's own comment has to carry
 // `RUN_MARKER`, or `issue-watch-diff.ts` reads it as a person's update: the run's review then reads as
@@ -125,6 +128,55 @@ const DIRECT_ISSUE_COMMENT_REASON =
 	'`pnpm josh issue:comment <N> --body-file <path>` instead (`shell-body.md`). ' +
 	'**This rule fires on every occurrence, not once per run.**'
 
+// **A standalone `gh issue comment <N> --body-file <path>` is rewritten rather than refused**
+// (joshuafolkken/kit#7330): `issue:comment` reads the file as it is, so the posted text is the same and
+// gains the run marker. The path is resolved against the call's cwd, since `pnpm josh` runs from the
+// package root. An inline `--body` keeps the refusal: `issue:comment` trims it and expands `\n`, so the
+// posted text could differ. So do stdin (`-`), a pipe, a chain, a quote and any other flag.
+const COMMENT_WORDS = ['gh', ISSUE_GROUP, COMMENT_ACTION]
+const BODY_FILE_SPELLING = /^(?:(?:-F|--body-file) |--body-file=)(?<file>[\w./-]+)$/u
+const STDIN_PATH = '-'
+const ISSUE_COMMENT_COMMAND = 'pnpm josh issue:comment'
+const BODY_FILE_FLAG = '--body-file'
+
+// The one body file the flags name, resolved against `cwd`, or `undefined` for any other spelling.
+function body_file_of(flags: string, cwd: string): string | undefined {
+	const file = BODY_FILE_SPELLING.exec(flags)?.groups?.['file']
+
+	return file === undefined || file === STDIN_PATH ? undefined : path.resolve(cwd, file)
+}
+
+function issue_comment_of(comment: StandaloneCall, cwd: string): string | undefined {
+	const resolved = body_file_of(comment.flags, cwd)
+
+	return resolved !== undefined && standalone_gh_call.is_plain_word(resolved)
+		? standalone_gh_call.line_of([ISSUE_COMMENT_COMMAND, comment.issue, BODY_FILE_FLAG, resolved])
+		: undefined
+}
+
+// `pnpm josh issue:comment` for a refused post that is a standalone `gh issue comment`, else
+// `undefined`. The word split runs first: it is cheap, and every Bash call passes through here.
+function issue_comment_command(command: string, context: HookContext): string | undefined {
+	const comment = standalone_gh_call.call_of(command, COMMENT_WORDS)
+	const post = comment === undefined ? undefined : issue_comment_of(comment, context.cwd)
+
+	return post !== undefined && is_direct_issue_comment_in(command.trim(), context)
+		? post
+		: undefined
+}
+
+function issue_comment_input(
+	call: GuardedCall,
+	_tail: () => string,
+	context: HookContext,
+): Record<string, unknown> | undefined {
+	return standalone_gh_call.input_of(call, (command) => issue_comment_command(command, context))
+}
+
+const ISSUE_COMMENT_NOTE =
+	'↻ direct issue comment: this `gh issue comment <N> --body-file <path>` ran as ' +
+	'`pnpm josh issue:comment <N> --body-file <path>`, which posts the run marker (`shell-body.md`).'
+
 const ROW = {
 	id: 'direct-issue-comment',
 	is_trigger: bash_triggers.on_bash_command(is_direct_issue_comment_in),
@@ -132,16 +184,24 @@ const ROW = {
 	decide: (): boolean => true,
 	keeps: bash_triggers.on_bash_command(is_josh_comment),
 	reaches: bash_triggers.on_bash_command(is_any_comment),
+	rewrite: issue_comment_input,
+	rewrite_note: ISSUE_COMMENT_NOTE,
 	about: {
 		title: 'Direct issue comment',
 		topic: '`shell-body.md`',
 		fires:
-			"a comment to the checkout's own repository outside `josh issue:comment` (`gh issue comment` with no `--repo`, or a `gh api` write to `repos/<owner>/<r>/issues/<N>/comments` whose owner is the `{owner}` placeholder or the checkout's own `owner/repo` spelled out); it points at `pnpm josh issue:comment`. Every occurrence",
+			"a comment to the checkout's own repository outside `josh issue:comment` (`gh issue comment` with no `--repo`, or a `gh api` write to `repos/<owner>/<r>/issues/<N>/comments` whose owner is the `{owner}` placeholder or the checkout's own `owner/repo` spelled out); it points at `pnpm josh issue:comment`. A line that is only `gh issue comment <N>` with one `--body-file` / `-F <path>` is rewritten to `pnpm josh issue:comment <N> --body-file <path>`; every other form is refused, every occurrence",
 		quiet:
 			'`pnpm josh issue:comment`, or reading the comments — the path that writes the run marker',
 	},
 }
 
-const direct_issue_comment = { DIRECT_ISSUE_COMMENT_REASON, ROW, is_direct_issue_comment }
+const direct_issue_comment = {
+	DIRECT_ISSUE_COMMENT_REASON,
+	ISSUE_COMMENT_NOTE,
+	ROW,
+	is_direct_issue_comment,
+	issue_comment_command,
+}
 
 export { direct_issue_comment }

package/scripts/rules/direct-issue-read.ts

@@ -1,10 +1,12 @@
 import { session_cite } from '#scripts/issue/session-cite'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { bash_triggers } from './bash-triggers'
 import { direct_pr_create } from './direct-pr-create'
 import { gh_api } from './gh-api'
 import { git_argv } from './git-argv'
 import { issue_comments } from './issue-comments'
 import { shell_segments } from './shell-segments'
+import { standalone_gh_call, type StandaloneCall } from './standalone-gh-call'
 
 // The `direct-issue-read` row of `delivered-rules.ts` (joshuafolkken/kit#4663). `pnpm josh issue:read`
 // is the one read that withholds a comment from an author without write access and marks an untrusted
@@ -25,6 +27,11 @@ import { shell_segments } from './shell-segments'
 //
 // **It fires on every occurrence**, and before `issue-comments`, whose rewrite would otherwise add the
 // unfiltered comments to the same call.
+//
+// **A standalone `gh issue view <N>` is rewritten rather than refused** (joshuafolkken/kit#7330): the
+// line is that one call with no flag but `-R` / `--repo <owner>/<repo>`, so `issue:read` takes every
+// argument it carries. The rewrite is `issue:read` itself, so an untrusted comment is still withheld.
+// A pipe, a chain, a redirect, a quote, a URL or any other flag keeps the refusal.
 
 const API_SUBCOMMAND = 'api'
 const ISSUE_GROUP = 'issue'
@@ -161,6 +168,44 @@ function is_any_read(command: string): boolean {
 	return is_direct_issue_read(command) || is_josh_read(command)
 }
 
+const VIEW_WORDS = ['gh', ISSUE_GROUP, VIEW_ACTION]
+const REPO_SPELLING = /^(?:(?:-R|--repo) |--repo=)(?<repo>[\w.-]+\/[\w.-]+)$/u
+const ISSUE_READ_COMMAND = 'pnpm josh issue:read'
+const REPO_FLAG = '--repo'
+
+// The `--repo` pair `issue:read` takes for the view's flags: none, or one `<owner>/<repo>`.
+function carried_repo(flags: string): ReadonlyArray<string> | undefined {
+	if (flags === '') return []
+	const repo = REPO_SPELLING.exec(flags)?.groups?.['repo']
+
+	return repo === undefined ? undefined : [REPO_FLAG, repo]
+}
+
+function issue_read_of(view: StandaloneCall): string | undefined {
+	const repo = carried_repo(view.flags)
+
+	return repo === undefined
+		? undefined
+		: standalone_gh_call.line_of([ISSUE_READ_COMMAND, view.issue, ...repo])
+}
+
+// `pnpm josh issue:read` for a refused read that is a standalone `gh issue view`, else `undefined`.
+// The word split runs first: it is cheap, and every Bash call passes through here.
+function issue_read_command(command: string): string | undefined {
+	const view = standalone_gh_call.call_of(command, VIEW_WORDS)
+	const read = view === undefined ? undefined : issue_read_of(view)
+
+	return read !== undefined && is_direct_issue_read(command.trim()) ? read : undefined
+}
+
+function issue_read_input(call: GuardedCall): Record<string, unknown> | undefined {
+	return standalone_gh_call.input_of(call, issue_read_command)
+}
+
+const ISSUE_READ_NOTE =
+	'↻ direct issue read: this `gh issue view <N>` ran as `pnpm josh issue:read <N>`, which withholds ' +
+	'a comment from an author without write access (`issue-comments.md`).'
+
 const DIRECT_ISSUE_READ_REASON =
 	'⛔ direct issue read: pnpm josh issue:read <N>\n' +
 	'Run that in place of this read of `…/issues/<N>`, its comments or its timeline (`gh api` or ' +
@@ -176,16 +221,24 @@ const ROW = {
 	decide: (): boolean => true,
 	keeps: bash_triggers.on_bash_command(is_josh_read),
 	reaches: bash_triggers.on_bash_command(is_any_read),
+	rewrite: issue_read_input,
+	rewrite_note: ISSUE_READ_NOTE,
 	about: {
 		title: 'Direct issue read',
 		topic: '`issue-comments.md`',
 		fires:
-			"a `gh api` GET of the checkout's own `repos/<o>/<r>/issues/<N>`, `…/comments` or `…/timeline` (the `{owner}` placeholder or the origin spelled out), or a `gh issue view <N>` of it, with no projection or one naming the body (or, for the view, the comments); it points at `pnpm josh issue:read`. Every occurrence",
+			"a `gh api` GET of the checkout's own `repos/<o>/<r>/issues/<N>`, `…/comments` or `…/timeline` (the `{owner}` placeholder or the origin spelled out), or a `gh issue view <N>` of it, with no projection or one naming the body (or, for the view, the comments); it points at `pnpm josh issue:read`. A line that is only `gh issue view <N>`, with at most `-R` / `--repo <owner>/<repo>`, is rewritten to `pnpm josh issue:read <N>`; every other form is refused, every occurrence",
 		quiet:
 			'`pnpm josh issue:read` / `run:prep` / `run:entry`, a `--jq` / `--json` projection without the body or the comments, `gh issue view --web`, or another repository named outright',
 	},
 }
 
-const direct_issue_read = { DIRECT_ISSUE_READ_REASON, ROW, is_direct_issue_read }
+const direct_issue_read = {
+	DIRECT_ISSUE_READ_REASON,
+	ISSUE_READ_NOTE,
+	ROW,
+	is_direct_issue_read,
+	issue_read_command,
+}
 
 export { direct_issue_read }

package/scripts/rules/guard-remedy.ts

@@ -31,6 +31,7 @@ const HOLD_RELEASE = 'the hook releases the hold itself; it blocks only when tha
 const FILING_OFFER = 'the filing needs a title and a body only the model can write'
 const CONCISE_REPLY = 'the shorter reply is prose only the model can write'
 const NARROW_ENOUGH = 'which reading is narrow enough to keep is the author’s call'
+const BODY_TO_FILE = 'the body moves to a file the call does not name'
 
 function rewrite(): GuardRemedy {
 	return { remedy: 'rewrite', why: REWRITTEN }
@@ -52,16 +53,21 @@ const GUARD_REMEDIES: Readonly<Record<string, GuardRemedy>> = {
 	'shell-body': judgment(
 		"which part of the body the shell was meant to expand is the author's, not the hook's",
 	),
-	'raw-field-body': judgment('the body moves to a file the call does not name'),
+	'raw-field-body': judgment(BODY_TO_FILE),
 	'credential-body': judgment(
 		'which text is the credential, and what replaces it, is the author’s',
 	),
 	'rule-body': judgment('a trigger-plus-pointer line is written, not derived'),
 	'direct-filing': judgment(ANOTHER_COMMAND),
 	'unasked-filing': judgment(NO_RUN),
-	'direct-issue-comment': judgment(ANOTHER_COMMAND),
-	'direct-issue-read': judgment(ANOTHER_COMMAND),
-	'direct-git-status': judgment(ANOTHER_COMMAND),
+	// A standalone `gh issue comment <N> --body-file <path>` run as `pnpm josh issue:comment`; an inline
+	// `--body` is refused, since `issue:comment` trims it and expands `\n` (joshuafolkken/kit#7330).
+	'direct-issue-comment': rewrite(),
+	'direct-issue-read': rewrite(), // a standalone `gh issue view <N>` run as `pnpm josh issue:read <N>`
+	'direct-git-status': judgment(
+		'the refusal is spent once per run and its reissue passes, so a rewrite saves at most one ' +
+			'round trip while trading the long-format listing the call asked for for porcelain',
+	),
 	'direct-vitest-run': judgment(ANOTHER_COMMAND),
 	'direct-pr-create': judgment(ANOTHER_COMMAND),
 	'pr-merge': judgment(ANOTHER_COMMAND),

package/scripts/rules/issue-citation.ts

@@ -152,16 +152,27 @@ function collect_line_references(line: string, found: Array<string>): void {
 	for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`)
 }
 
-// The message lines that sit outside every fenced-code block, with the fence delimiter lines
-// themselves dropped: toggling on each delimiter brackets the block, so a `#N` shown in an example is
-// never scanned.
+function closes_fence(line: string, marker: string, fence: string): boolean {
+	return marker.startsWith(fence) && line.trim() === marker
+}
+
+function fence_after(line: string, fence: string): string {
+	const match = FENCE_MARKER.exec(line)
+	if (match === null) return fence
+	const marker = match[0].trimStart()
+	if (fence === '') return marker
+
+	return closes_fence(line, marker, fence) ? '' : fence
+}
+
+// Skip through a matching closing fence, including unlike or shorter delimiters inside it.
 function lines_outside_fences(message: string): ReadonlyArray<string> {
 	const lines: Array<string> = []
-	let is_in_fence = false
+	let fence = ''
 
 	for (const line of message.split('\n')) {
-		if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence
-		else if (!is_in_fence) lines.push(line)
+		fence = fence_after(line, fence)
+		if (fence === '' && !FENCE_MARKER.test(line)) lines.push(line)
 	}
 
 	return lines
@@ -231,11 +242,11 @@ function rewrite_line(line: string, slug: string, is_in_fence: boolean): string
 // fed the duplicate reply. Fence state is carried across lines, since a fenced block spans them.
 function linkify(message: string, slug: string): string {
 	const out: Array<string> = []
-	let is_in_fence = false
+	let fence = ''
 
 	for (const line of message.split('\n')) {
-		if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence
-		out.push(rewrite_line(line, slug, is_in_fence))
+		fence = fence_after(line, fence)
+		out.push(rewrite_line(line, slug, fence !== ''))
 	}
 
 	return out.join('\n')

package/scripts/rules/last-prompt.ts

@@ -1,6 +1,7 @@
 import { json_value } from '#scripts/lib/json-value'
 import { time_reported_failure } from '#scripts/time-runtime/time-reported-failure'
 import { z } from 'zod'
+import { codex_prompt } from './codex-prompt'
 import { turn_filings } from './turn-filings'
 
 // The person's prompts on a transcript tail — what the stop guard reads to tell a question it answers
@@ -34,7 +35,9 @@ function is_person(line: PromptLine): boolean {
 // The prompt line as the person wrote it, or `undefined` when the harness wrote it or it does not
 // read as one.
 function person_line(line: string): PromptLine | undefined {
-	const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line))
+	const normalized = codex_prompt.normalize(line)
+	if (!turn_filings.is_prompt_line(normalized)) return undefined
+	const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(normalized))
 
 	return parsed.success && is_person(parsed.data) ? parsed.data : undefined
 }
@@ -51,7 +54,10 @@ function person_text(line: string): string | undefined {
 // notification, a subagent's hand-back), so a question asked turns ago does not answer for a stop the
 // run reached on its own since (`stop-decision.ts` → `is_question`).
 function turn_prompt(tail: string): string {
-	const opener = tail.split('\n').findLast((line) => turn_filings.is_prompt_line(line))
+	const opener = tail
+		.split('\n')
+		.map((line) => codex_prompt.normalize(line))
+		.findLast((line) => turn_filings.is_prompt_line(line))
 	if (opener === undefined) return NO_PROMPT
 
 	return person_text(opener) ?? NO_PROMPT
@@ -63,7 +69,6 @@ function turn_prompt(tail: string): string {
 function person_prompt(tail: string): string | undefined {
 	return tail
 		.split('\n')
-		.filter((line) => turn_filings.is_prompt_line(line))
 		.map((line) => person_text(line))
 		.findLast((text) => text !== undefined)
 }
@@ -72,7 +77,6 @@ function person_prompt(tail: string): string | undefined {
 function prompt_time(tail: string): string | undefined {
 	return tail
 		.split('\n')
-		.filter((line) => turn_filings.is_prompt_line(line))
 		.map((line) => person_line(line)?.timestamp ?? undefined)
 		.findLast((time) => time !== undefined)
 }