@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/review/review-untouched-readers.ts

@@ -0,0 +1,146 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { git_grep_hits, type Hit } from '#scripts/git/git-grep-hits'
+import { git_spawn } from '#scripts/git/git-spawn'
+import { review_readers_scan, type Edited } from './review-readers-scan'
+
+// The readers outside the diff of each exported name the diff edits, listed in the brief
+// (joshuafolkken/kit#4515). A reader the change left on the old meaning was the most common kind of
+// finding that stopped a lane review; the self-check's "Every caller moved with it" asked for the
+// search and left it to the implementer, and this does it mechanically for the reviewer to read.
+//
+// **A reader is a line outside the changed paths that names the edited name as a word** — a
+// re-derivation or an alias is not found, and the list says so. A grep that could not run is printed
+// as such, never as "no readers".
+
+const SOURCE_FILE = /\.(?:ts|js)$/u
+const SEARCH_PATHS = ['*.ts', '*.js', '*.svelte', ':(exclude)*.snap']
+const WORD_FLAG = '-w'
+const MAX_HITS = 10
+const MAX_NAMES = 30
+const HEADING = '## Readers outside the diff'
+const ROLE_LINE =
+	'Each exported name this change edits, with every line outside the changed paths that names it (`git grep -w`). Check each reader still holds under the new meaning — the self-check\'s "Every caller moved with it" (`prompts/review.md`). A reader left on the old meaning is a finding at the reader\'s `file:line`. A reader reaching the name through an alias or a re-derivation is not listed.'
+const SEARCH_FAILED = '  - git grep failed; not searched'
+const READ_FAILED = 'The readers outside the diff could not be read; search them yourself:'
+const OMITTED_TAIL = 'not searched; search their readers yourself'
+
+interface Readers {
+	target: string
+	origin: string
+	hits: ReadonlyArray<Hit>
+	has_failed: boolean
+}
+
+// `omitted` counts the edited names past `MAX_NAMES`, which were never searched.
+interface ReadersRead {
+	readers: ReadonlyArray<Readers>
+	omitted: number
+	has_failed: boolean
+}
+
+const NO_READ: ReadersRead = { readers: [], omitted: 0, has_failed: false }
+const FAILED_READ: ReadersRead = { readers: [], omitted: 0, has_failed: true }
+
+interface ReadRequest {
+	root: string
+	base: string
+	paths: ReadonlyArray<string>
+}
+
+interface FileEdits {
+	relative: string
+	edits: ReadonlyArray<Edited>
+}
+
+async function file_edits(request: ReadRequest, relative: string): Promise<FileEdits> {
+	const { root, base } = request
+	const diff = await git_spawn.read(['-C', root, 'diff', '-U0', '--no-color', base, '--', relative])
+
+	if (diff.length === 0) return { relative, edits: [] }
+
+	// A path the change deletes has no text; its readers fail the typecheck rather than read stale.
+	try {
+		const source = readFileSync(path.join(root, relative), 'utf8')
+
+		return { relative, edits: review_readers_scan.edited(source, diff) }
+	} catch {
+		return { relative, edits: [] }
+	}
+}
+
+function excluded(paths: ReadonlyArray<string>): Array<string> {
+	return paths.map((relative) => `:(exclude,literal)${relative}`)
+}
+
+async function readers_of(request: ReadRequest, entry: FileEdits, edit: Edited): Promise<Readers> {
+	const pathspecs = [...SEARCH_PATHS, ...excluded(request.paths)]
+	const found = await git_grep_hits.search(edit.target, [WORD_FLAG], pathspecs, request.root)
+
+	return { target: edit.target, origin: `${entry.relative}:${String(edit.line)}`, ...found }
+}
+
+// Every edited name, with its readers outside `paths`. Only names that have a reader, or whose search
+// failed, are returned; the names past the cap are counted, never dropped silently.
+async function read(request: ReadRequest): Promise<ReadersRead> {
+	const sources = request.paths.filter((relative) => SOURCE_FILE.test(relative))
+	const files = await Promise.all(
+		sources.map(async (relative) => await file_edits(request, relative)),
+	)
+	const pairs = files.flatMap((entry) => entry.edits.map((edit) => ({ entry, edit })))
+	const capped = pairs.slice(0, MAX_NAMES)
+	const all = await Promise.all(
+		capped.map(async ({ entry, edit }) => await readers_of(request, entry, edit)),
+	)
+
+	const readers = all.filter((entry) => entry.has_failed || entry.hits.length > 0)
+
+	return { readers, omitted: pairs.length - capped.length, has_failed: false }
+}
+
+function hit_line(hit: Hit): string {
+	return `  - ${hit.path}:${hit.line}  ${hit.excerpt}`
+}
+
+function readers_lines(readers: Readers): Array<string> {
+	const head = `- \`${readers.target}\` — ${readers.origin}`
+
+	if (readers.has_failed) return [head, SEARCH_FAILED]
+
+	const more = readers.hits.length - MAX_HITS
+	const tail = more > 0 ? [`  - … and ${String(more)} more`] : []
+
+	return [head, ...readers.hits.slice(0, MAX_HITS).map((hit) => hit_line(hit)), ...tail]
+}
+
+function omitted_lines(omitted: number): Array<string> {
+	if (omitted === 0) return []
+
+	return [`- … and ${String(omitted)} more edited names ${OMITTED_TAIL}`]
+}
+
+// A read that failed as a whole says so, never reads as a change with no reader outside it; absent
+// or empty, no section.
+function brief_block(read_result: ReadersRead = NO_READ): ReadonlyArray<string> {
+	const { readers, omitted, has_failed } = read_result
+
+	if (has_failed) return ['', `${HEADING}\n${READ_FAILED}`]
+	if (omitted === 0 && readers.length === 0) return []
+
+	const listed = readers.flatMap((entry) => readers_lines(entry))
+
+	return ['', [HEADING, ROLE_LINE, ...listed, ...omitted_lines(omitted)].join('\n')]
+}
+
+const review_untouched_readers = {
+	brief_block,
+	FAILED_READ,
+	HEADING,
+	MAX_NAMES,
+	OMITTED_TAIL,
+	read,
+	READ_FAILED,
+}
+
+export type { Readers, ReadersRead }
+export { review_untouched_readers }

package/scripts/review/test-titles.ts

@@ -0,0 +1,118 @@
+import type ts from 'typescript'
+import type { TypeScriptApi } from './comment-ranges'
+
+// The tests a test file declares, each as its full name — the titles of the `describe` blocks around it
+// joined to its own `it` / `test` title — so two tests with the same title under different blocks
+// stay apart.
+//
+// **Read from the TypeScript parser, never from a pattern**: a title holding a quote or a bracket, or
+// a call split over lines, is exactly what a hand-written scanner misreads. `it.skip(…)`,
+// `test.each([…])(…)` and `describe.concurrent(…)` are the same test with a modifier, so a call
+// counts by the names its callee chain is built from: Playwright's `test.describe(…)` is a block and
+// its `test.step(…)` is part of the test around it, never a test. A template title with substitutions is kept
+// as its source text; a title held in a variable has no text to compare and is not listed.
+//
+// **A `describe` is a name, never a test**: renaming one moves the tests under it, and removing it
+// removes them, so only the `it` / `test` calls are listed.
+
+const BLOCK_FUNCTION = 'describe'
+const STEP_FUNCTION = 'step'
+const TEST_FUNCTIONS: ReadonlySet<string> = new Set(['it', 'test'])
+const TITLE_SEPARATOR = ' > '
+const VIRTUAL_FILE_NAME = 'test-titles.ts'
+
+type Prefix = ReadonlyArray<string>
+
+interface NamedCall {
+	chain: ReadonlyArray<string>
+	title: string
+}
+
+interface Walk {
+	api: TypeScriptApi
+	source: ts.SourceFile
+	into: Array<string>
+}
+
+function member_name(api: TypeScriptApi, expression: ts.Expression): ReadonlyArray<string> {
+	return api.isPropertyAccessExpression(expression) ? [expression.name.text] : []
+}
+
+// The names a callee chain is built from, root first: `test.describe.parallel` is
+// `['test', 'describe', 'parallel']`, and `it.each([…])` is `['it', 'each']`.
+function callee_chain(
+	api: TypeScriptApi,
+	expression: ts.Expression,
+): ReadonlyArray<string> | undefined {
+	if (api.isIdentifier(expression)) return [expression.text]
+	const is_chained = api.isPropertyAccessExpression(expression) || api.isCallExpression(expression)
+	const chain = is_chained ? callee_chain(api, expression.expression) : undefined
+
+	return chain === undefined ? undefined : [...chain, ...member_name(api, expression)]
+}
+
+function is_block(chain: ReadonlyArray<string>): boolean {
+	return chain.includes(BLOCK_FUNCTION)
+}
+
+function is_test(chain: ReadonlyArray<string>): boolean {
+	const [root = ''] = chain
+
+	return TEST_FUNCTIONS.has(root) && !is_block(chain) && !chain.includes(STEP_FUNCTION)
+}
+
+// Only a string or a template can be a title: the array `it.each([…])` is first called with is the
+// table of cases, not a name.
+function title_of(walk: Walk, call: ts.CallExpression): string | undefined {
+	const [first] = call.arguments
+
+	if (first === undefined) return undefined
+	if (walk.api.isStringLiteralLike(first)) return first.text
+
+	return walk.api.isTemplateExpression(first) ? first.getText(walk.source) : undefined
+}
+
+function named_call(walk: Walk, node: ts.Node): NamedCall | undefined {
+	if (!walk.api.isCallExpression(node)) return undefined
+	const chain = callee_chain(walk.api, node.expression)
+	const title = chain === undefined ? undefined : title_of(walk, node)
+
+	return chain === undefined || title === undefined ? undefined : { chain, title }
+}
+
+// The block titles a call adds to the name of everything inside it: a `describe` adds its own, a
+// test is listed and adds nothing further down, and any other node passes its prefix through.
+function entered(walk: Walk, call: NamedCall | undefined, prefix: Prefix): Prefix {
+	if (call === undefined) return prefix
+	const named = [...prefix, call.title]
+
+	if (is_test(call.chain)) walk.into.push(named.join(TITLE_SEPARATOR))
+
+	return is_block(call.chain) ? named : prefix
+}
+
+function visit(walk: Walk, node: ts.Node, prefix: Prefix): void {
+	const inner = entered(walk, named_call(walk, node), prefix)
+
+	walk.api.forEachChild(node, (child) => {
+		visit(walk, child, inner)
+	})
+}
+
+function titles_of(api: TypeScriptApi, text: string): ReadonlyArray<string> {
+	const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, true)
+	const into: Array<string> = []
+
+	visit({ api, source, into }, source, [])
+
+	return into
+}
+
+// The title a test carries itself, without the blocks around it.
+function leaf_of(full_name: string): string {
+	return full_name.split(TITLE_SEPARATOR).at(-1) ?? full_name
+}
+
+const test_titles = { leaf_of, titles_of }
+
+export { test_titles }

package/scripts/rules/agent-model.ts

@@ -52,8 +52,16 @@ const ROW = {
 	decide: (): boolean => true,
 	keeps: keeps_model,
 	reaches: is_general_purpose,
+	about: {
+		title: 'Subagent model named',
+		topic:
+			'`.claude/skills/workflow-commands/delegation.md` → "A `general-purpose` subagent names its model"',
+		fires:
+			'an `Agent` / `Task` call of the `general-purpose` type with no `model`. Every occurrence',
+		quiet: 'a named agent type, or a `model` set',
+	},
 }
 
-const agent_model = { AGENT_MODEL_REASON, ROW, is_unnamed_model }
+const agent_model = { AGENT_MODEL_REASON, ROW, SUBAGENT_TOOLS, is_unnamed_model }
 
 export { agent_model }

package/scripts/rules/bash-triggers.ts

@@ -1,12 +1,13 @@
 import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { time_shell } from '#scripts/time-runtime/time-shell'
+import { git_argv } from './git-argv'
 import { shell_segments } from './shell-segments'
 
 // The trigger helpers the enumeration in `delivered-rules.ts` is built from, held here so a rule
 // that lives in its own module can build its own row without importing the enumeration back.
-// `is_issue_filing` is the one three rows share — the WIP cap, the per-run
-// filing cap and the fold — so it could not stay a private function of the file that spreads their rows.
+// `is_issue_filing` is shared by the readers of a run's filings off the transcript (`turn-filings.ts`,
+// `stop-guard.ts`), so it could not stay a private function of one of them.
 
 // **Only `Bash`, and the omission is deliberate**: Claude Code denies one
 // call of a turn and runs the rest, so a refused `Edit` would leave its siblings applied and itself
@@ -35,14 +36,56 @@ const TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u
 
 // A filing made by hand rather than through `josh issue:file` — the call the `direct-filing` row
 // refuses on every occurrence.
+//
+// **Read outside quotes, but not outside a heredoc** (joshuafolkken/kit#4525). `echo "… gh issue create
+// …"` files nothing, so the `gh` call is matched on the unquoted line — which keeps a `"$(gh issue
+// create …)"` that runs. A heredoc body is matched as written: `bash <<EOF` runs it, and the body cannot
+// be told apart from prose, so the rule errs on the refusing side. The endpoint and the title field are
+// still read from the line as written, where a quoted path or field keeps them.
+//
+// **A quoted script handed to a shell runs, so it is read as written too**: `bash -c "gh issue create
+// …"`, `sh -c '…'` and `eval "…"` file the Issue the quotes would otherwise hide.
+const GH_API_COMMAND = /\bgh\s+api\b/u
+const SHELL_SCRIPT_RUNNER = /\b(?:(?:ba|z|da|k)?sh\s+(?:-\w+\s+)*-\w*c\b|eval\b)/u
+
+function spoken_line(command: string): string {
+	if (time_shell.has_heredoc(command)) return command
+
+	const plain = time_shell.unquoted(command)
+
+	return SHELL_SCRIPT_RUNNER.test(plain) ? command : plain
+}
+
+const LEADING_SHELL_SCRIPT_RUNNER = new RegExp(`^${SHELL_SCRIPT_RUNNER.source}`, 'u')
+const QUOTE_MARK = /["']/gu
+
+// The quoted script a segment's shell runs, as a line of its own: `sh -c 'pnpm exec eslint .'` reads
+// as `pnpm exec eslint .`, so a caller cutting it into commands reads the programs the script
+// launches. Only when the segment's program is the runner — `echo sh -c x` hands no script to a shell.
+// `undefined` when the segment runs no shell script.
+function shell_script_of(segment: string): string | undefined {
+	const call = git_argv.program_of(segment)
+
+	if (call === undefined) return undefined
+
+	const spoken = [call.name, ...call.args].join(' ')
+	const runner = LEADING_SHELL_SCRIPT_RUNNER.exec(spoken)
+
+	if (runner === null) return undefined
+
+	return spoken.slice(runner[0].length).replaceAll(QUOTE_MARK, '').trim()
+}
+
 function is_direct_filing(command: string): boolean {
-	if (ISSUE_CREATE_COMMAND.test(command)) return true
+	const spoken = spoken_line(command)
+
+	if (ISSUE_CREATE_COMMAND.test(spoken)) return true
 
-	return ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command)
+	return GH_API_COMMAND.test(spoken) && ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command)
 }
 
 // `pnpm josh issue:file`, in either spelling — **the** filing act once a direct one is refused, so the
-// run-level filing rows (the WIP cap, the per-run cap, the fold) trigger on it. Segment-wise, so a
+// turn's filing count reads it. Segment-wise, so a
 // spelling quoted inside another command's body is not read as a filing.
 const FILING_NAMES: ReadonlySet<string> = new Set(['issue:file'])
 
@@ -52,6 +95,6 @@ function is_issue_filing(command: string): boolean {
 		.some((segment) => shell_segments.is_josh_command(segment, FILING_NAMES))
 }
 
-const bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command }
+const bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command, shell_script_of }
 
 export { bash_triggers }

package/scripts/rules/concise-reply.ts

@@ -0,0 +1,88 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { document_section } from '#scripts/document/document-section'
+import { find_package_directory } from '#scripts/josh/package-directory'
+import type { MeasuredRule } from './delivered-rules'
+import { reply_prose } from './reply-prose'
+import { stop_decision } from './stop-decision'
+
+// A chat reply leads with its conclusion and keeps its narrative short: the procedure is
+// `prompts/collaboration-workflow/principles.md` → "concise-reply"; the limit is this file's.
+
+// Letters and digits of narrative — prose outside code, tables and lists. Counted, not characters, so
+// markdown markers and punctuation weigh nothing in any language.
+const PROSE_LIMIT = 400
+// A person who asked for the detail is answered with it.
+const EXEMPT_WORDS: ReadonlyArray<string> = ['詳しく', '具体的に', '詳細']
+const COUNTED_PATTERN = /[\p{L}\p{N}]/gu
+
+const PRINCIPLES_FILE = 'prompts/collaboration-workflow/principles.md'
+const SECTION = 'concise-reply'
+const PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(import.meta.url)))
+
+// The constant opening `rule-value.ts` credits a Stop refusal to this row by.
+const REASON_OPENING = `⛔ concise reply: your reply's prose outside code, tables and lists is over the limit of \`${PRINCIPLES_FILE}\` → "${SECTION}"`
+
+const KEEP_DECISION = ' Keep its `Recommended:` / `Alternative:` lines as they are.'
+
+function prose_length(message: string): number {
+	return reply_prose.narrative_of(message).match(COUNTED_PATTERN)?.length ?? 0
+}
+
+function is_exempt(prompt: string): boolean {
+	return EXEMPT_WORDS.some((word) => prompt.includes(word))
+}
+
+// `prompt` is the person's last prompt — `undefined` when it could not be read, and then whether they
+// asked for the detail is unknown, so nothing is refused.
+function is_over(message: string, prompt: string | undefined): boolean {
+	if (prompt === undefined || is_exempt(prompt)) return false
+
+	return prose_length(message) > PROSE_LIMIT
+}
+
+function section_text(root: string): string | undefined {
+	const markdown = document_section.read_optional(path.join(root, PRINCIPLES_FILE))
+
+	return markdown === undefined ? undefined : document_section.section(markdown, SECTION)?.text
+}
+
+// A held run's notify reads the decision off the rewrite, which the loop-breaker lets stop unchecked.
+function decision_note(message: string): string {
+	return stop_decision.decision_of(message) === undefined ? '' : KEEP_DECISION
+}
+
+// The refusal carries the section itself, so the rewrite needs no read.
+function build_reason(message: string, root: string = PACKAGE_DIRECTORY): string {
+	const head =
+		`${REASON_OPENING} (${String(prose_length(message))} of ${String(PROSE_LIMIT)}). Rewrite it ` +
+		`shorter as that section says — do not repeat your previous reply.${decision_note(message)}`
+	const body = section_text(root)
+
+	return body === undefined ? head : `${head}\n\n${body}`
+}
+
+const ROW: MeasuredRule = {
+	id: SECTION,
+	reason: REASON_OPENING,
+	about: {
+		title: 'Concise reply',
+		topic: `\`principles.md\` → "${SECTION}"`,
+		entry: 'pnpm josh stop:guard',
+		fires: `a reply whose narrative outside code, tables and lists is over ${String(PROSE_LIMIT)} letters. Blocks the stop`,
+		quiet:
+			'a reply under the limit, a prompt asking for the detail (`詳しく` / `具体的に` / `詳細`), a fixed output in a code block, no prompt of the person’s on the transcript tail, or a headless session',
+	},
+}
+
+const concise_reply = {
+	EXEMPT_WORDS,
+	PROSE_LIMIT,
+	REASON_OPENING,
+	ROW,
+	build_reason,
+	is_over,
+	prose_length,
+}
+
+export { concise_reply }

package/scripts/rules/credential-body.ts

@@ -0,0 +1,77 @@
+import { file_reader } from '#scripts/lib/read-file'
+import { token_shape } from '#scripts/lib/token-shape'
+import { bash_triggers } from './bash-triggers'
+import { direct_pr_create } from './direct-pr-create'
+import { gh_api, type FieldSource } from './gh-api'
+import { git_argv } from './git-argv'
+
+// The `credential-body` row of `delivered-rules.ts`. A body kit sends is refused when it holds a
+// token-shaped string (`git-gh-exec.ts`, joshuafolkken/kit#4658), but a `gh api` call a run types on
+// the shell never passes through kit's code, so the same scan runs here before the call does
+// (joshuafolkken/kit#4682). The shapes are `token-shape.ts`'s, read by `token_shape.holds` — the test
+// `token_shape.refuse` throws on — so no second copy of a pattern exists.
+//
+// **The text `gh` would send, not the command line alone**: each field value, and the file a
+// `-F key=@<path>` or `--input <path>` names, read as the hook sees it — a path relative to a
+// directory a `cd` earlier on the line moved to is not found and reads as empty. A JSON body is scanned
+// decoded, as the in-process send does.
+//
+// **It fires on every occurrence**, for the reason `git-force.ts` does.
+
+// `gh` sends a typed `\n` as the two characters, so a token after it follows the letter `n` and the
+// shapes' "no letter before it" guard would pass it. So the text is scanned twice — as sent, and with
+// each escape read as a space — since a backslash may also sit right before the token (`\ghp_…`),
+// where the second reading loses its first letter. A non-JSON file is read the same way.
+const TYPED_ESCAPE = /\\./gu
+
+function sent_text(source: FieldSource): string {
+	if (source.kind === 'text') return source.value
+
+	return token_shape.decoded(file_reader.read_if_readable(source.value) ?? '')
+}
+
+function holds_token(text: string): boolean {
+	return [text, text.replaceAll(TYPED_ESCAPE, () => ' ')].some((reading) =>
+		token_shape.holds(reading),
+	)
+}
+
+function is_credential_segment(segment: string): boolean {
+	const args = git_argv.arguments_of(segment, direct_pr_create.GH_COMMAND)
+
+	if (args === undefined) return false
+
+	const call = [direct_pr_create.GH_COMMAND, ...args].join(' ')
+
+	if (!gh_api.is_gh_api(call)) return false
+
+	return gh_api.field_sources(call).some((source) => holds_token(sent_text(source)))
+}
+
+function sends_credential(command: string): boolean {
+	return direct_pr_create.has_run_segment(command, is_credential_segment)
+}
+
+const CREDENTIAL_BODY_REASON =
+	'⛔ credential in a gh api body: a field value, or the file `-F key=@<path>` / `--input <path>` ' +
+	'names, holds a token-shaped string (`scripts/lib/token-shape.ts`), and the call would publish it. ' +
+	'Remove the credential from the body and send it again. ' +
+	'**This rule fires on every occurrence, not once per run.**'
+
+const ROW = {
+	id: 'credential-body',
+	is_trigger: bash_triggers.on_bash_command(sends_credential),
+	reason: CREDENTIAL_BODY_REASON,
+	decide: (): boolean => true,
+	about: {
+		title: 'Credential in a body',
+		topic: '`shell-body.md`',
+		fires:
+			'a `gh api` call whose field value, or the file `-F key=@<path>` / `--input <path>` names, holds a token-shaped string (`token-shape.ts`). Every occurrence',
+		quiet: 'a body with no credential, or a body sent through kit, which runs the same scan',
+	},
+}
+
+const credential_body = { CREDENTIAL_BODY_REASON, ROW, sends_credential }
+
+export { credential_body }

package/scripts/rules/decision-oracle-batch.ts

@@ -33,6 +33,7 @@ const EPIC_NEXT_REFERENCE = 'docs/josh-commands-backlog.md → `josh epic:next`'
 const BACKLOG_BUDGET_REFERENCE = 'docs/josh-commands-backlog.md → `josh backlog:budget`'
 const RUN_LIVENESS_REFERENCE = 'docs/josh-commands-run.md → `josh run:liveness`'
 const AUTO_OK_NEXT_REFERENCE = 'docs/josh-commands-backlog.md → `josh auto-ok:next`'
+const STASH_PUSH_REFERENCE = 'docs/josh-commands-backlog.md → `josh stash:push`'
 
 // Command used by two separate oracle entries (run:cut:resume and run:cut:gate).
 const RUN_CUT_CMD = 'run:cut'
@@ -65,9 +66,16 @@ const BATCH_ORACLES: ReadonlyArray<DecisionOracle> = [
 		name: 'run:liveness',
 		decision: 'Whether a delegated unit is still working or has stopped without reporting',
 		args: `${ISSUE_N_ARG} --output <path>`,
-		vocabulary: ['alive', 'stopped', 'settled', 'undetermined'],
+		vocabulary: ['alive', 'paused', 'stopped', 'settled', 'undetermined'],
 		single_source: RUN_LIVENESS_REFERENCE,
 	},
+	{
+		name: 'stash:push',
+		decision: 'Whether the working tree had anything outside the observation ledger to set aside',
+		args: '<message>',
+		vocabulary: ['stashed', 'clean'],
+		single_source: STASH_PUSH_REFERENCE,
+	},
 	{
 		name: 'stash:pop',
 		decision: 'Whether a named stash entry exists and can be applied',

package/scripts/rules/decision-oracle.ts

@@ -66,7 +66,7 @@ const DECISION_ORACLES: ReadonlyArray<DecisionOracle> = [
 	{
 		name: 'review:round2',
 		decision: 'Whether the second /code-review round is due',
-		args: '[--round-1-closed]',
+		args: '[--record <N>]',
 		vocabulary: [REQUIRED, SKIP],
 		single_source: CHAIN_RULE_MD,
 	},
@@ -152,9 +152,9 @@ const DECISION_ORACLES: ReadonlyArray<DecisionOracle> = [
 	{
 		name: 'cases',
 		decision:
-			'Each boundary a change crosses (network, process, fs, time) and the abnormal cases it owes',
+			'Each boundary a change crosses (network, process, fs, time, shared state, environment) and the abnormal cases it owes',
 		args: '<path...>',
-		vocabulary: ['network', 'process', 'fs', 'time', NONE],
+		vocabulary: ['network', 'process', 'fs', 'time', 'state', 'env', NONE],
 		single_source: 'prompts/collaboration-workflow/report-format.md → 変更とテスト',
 	},
 	{