@joshuafolkken/kit 1.978.0 → 1.998.0

package/scripts/test/test-declared.ts

@@ -76,36 +76,48 @@ function typed_runtime_file(path: string): string {
 	return `${test_type_logic.test_type_for(path)} — ${path}`
 }
 
+const BROWSER_CHECK = 'confirm the rendered page in a browser'
+const RUN_CHECK = 'run the changed code by hand and report what you observed'
+
+// The manual confirmation a basic-profile exemption owes, one instruction per kind of file it covers:
+// HTML/CSS is looked at in a browser, a source kit cannot test is run by hand (joshuafolkken/kit#2820).
+function manual_instruction(paths: ReadonlyArray<string>, is_basic: boolean): string {
+	const manual = test_declared_logic.manual_check_files(paths, is_basic)
+	const has_visual = manual.some((path) => test_declared_logic.is_basic_visual(path))
+	const has_source = manual.some((path) => !test_declared_logic.is_basic_visual(path))
+	const steps = [has_visual ? BROWSER_CHECK : '', has_source ? RUN_CHECK : ''].filter(Boolean)
+
+	return steps.length === 0 ? '' : ` — ${steps.join('; ')}`
+}
+
 // The word is stdout so a caller can read it alone; the reason — which files, and why — is stderr.
-function exempt_detail(paths: ReadonlyArray<string>, is_static: boolean): string {
-	const exempt = test_declared_logic.exempt_files(paths, is_static)
-	const has_visual = is_static && exempt.some((path) => /\.(?:html|css)$/u.test(path))
-	const instruction = has_visual ? ' — confirm the rendered page in a browser' : ''
+function exempt_detail(paths: ReadonlyArray<string>, is_basic: boolean): string {
+	const exempt = test_declared_logic.exempt_files(paths, is_basic)
 
-	return `exempt paths: ${exempt.join(', ')}${instruction}`
+	return `exempt paths: ${exempt.join(', ')}${manual_instruction(paths, is_basic)}`
 }
 
-function detail_for(verdict: Verdict, paths: ReadonlyArray<string>, is_static = false): string {
+function detail_for(verdict: Verdict, paths: ReadonlyArray<string>, is_basic = false): string {
 	if (verdict === 'required') {
 		const typed = test_declared_logic
-			.runtime_files(paths, is_static)
+			.runtime_files(paths, is_basic)
 			.map((path) => typed_runtime_file(path))
 
 		return `runtime files with no test: ${typed.join(', ')}`
 	}
 
-	if (verdict === 'exempt') return exempt_detail(paths, is_static)
+	if (verdict === 'exempt') return exempt_detail(paths, is_basic)
 
 	return 'a test file changed'
 }
 
 function report(
 	paths: ReadonlyArray<string>,
-	is_static: boolean = project_checks.is_static(process.cwd()),
+	is_basic: boolean = project_checks.is_basic(process.cwd()),
 ): { detail: string; verdict: Verdict } {
-	const verdict = test_declared_logic.verdict_for(paths, is_static)
+	const verdict = test_declared_logic.verdict_for(paths, is_basic)
 
-	return { detail: detail_for(verdict, paths, is_static), verdict }
+	return { detail: detail_for(verdict, paths, is_basic), verdict }
 }
 
 function run(): void {

package/scripts/test/test-unit-guard.ts

@@ -21,8 +21,8 @@ const NODE_MODULES = 'node_modules'
 // - **`vitest` absent is the young project.** `josh init` installs no vitest and writes no
 //   `test:unit` script, so a freshly-bootstrapped project always lands here — which is the case the
 //   skip was written for, and it keeps it.
-// - **`vitest` present is the node project's declaration that it runs unit tests.** Zero matching
-//   files there is a broken state — a mis-scoped glob, or a deleted suite — and fails. A static
+// - **`vitest` present is the full project's declaration that it runs unit tests.** Zero matching
+//   files there is a broken state — a mis-scoped glob, or a deleted suite — and fails. A basic
 //   project may carry vitest as an unused dependency without declaring a unit suite; zero files
 //   there are reported as skipped, never as a test pass.
 //
@@ -47,19 +47,19 @@ type GuardAction = 'run' | typeof SKIP_ACTION | typeof SKIP_NO_TESTS_ACTION | ty
 // body, and without this a gate that skipped the whole unit suite printed the same five lines as one
 // that ran it.
 const SKIP_REASON = 'vitest is not installed'
-const SKIP_NO_TESTS_REASON = 'no unit test files were found in this static project'
+const SKIP_NO_TESTS_REASON = 'no unit test files were found in this basic project'
 const FAIL_REASON =
 	'vitest is installed but no *.{test,spec}.{ts,js} test file was found — refusing to report a unit check that ran nothing'
 
 function resolve_guard_action(
 	is_installed: boolean,
 	has_tests: boolean,
-	is_static = false,
+	is_basic = false,
 ): GuardAction {
 	if (!is_installed) return SKIP_ACTION
 	if (has_tests) return 'run'
 
-	return is_static ? SKIP_NO_TESTS_ACTION : FAIL_ACTION
+	return is_basic ? SKIP_NO_TESTS_ACTION : FAIL_ACTION
 }
 
 function is_vitest_installed(project_directory: string): boolean {
@@ -160,7 +160,7 @@ async function run_guarded_vitest(
 	const action = resolve_guard_action(
 		is_installed,
 		has_tests,
-		project_checks.is_static(project_directory),
+		project_checks.is_basic(project_directory),
 	)
 
 	if (action !== 'run') return report_no_run(action, command_label)

package/scripts/time-runtime/time-shell.ts

@@ -45,7 +45,17 @@ const CHAIN_PATTERN = /&&|\|\||;/u
 // invisible here. Erring this way is the cheaper error for every caller: a missed reading costs
 // nothing beyond the reading, while a fragment read as a command answers about work the shell never
 // did, on the shape this repository writes constantly.
-const QUOTED_SPAN_PATTERN = /'[^']*'|"[^"]*"/gu
+//
+// **Escapes and heredoc bodies are text too** (joshuafolkken/kit#2841). A backslash outside single
+// quotes makes the next character literal, so `it\'s` opens nothing and a `"` closes only at an
+// unescaped `"`; inside `'…'` a backslash is an ordinary character, so `'C:\'` still closes. A heredoc
+// body is not shell syntax at all — an `it's` there is prose — so it is removed before the quotes are
+// paired, keeping the rest of its marker line (`cat <<EOF > f && git add f`) where the shell reads it.
+// Without both, a stray quote paired with one much later and erased every command between them.
+const QUOTED_SPAN_PATTERN = /\\[\s\S]|'[^']*'|"(?:\\[\s\S]|[^"\\])*"/gu
+const HEREDOC_MARKER = /(?<!<)<<-?\s*(['"]?)(\w+)\1/u
+const HEREDOC_DELIMITER_GROUP = 2
+const LINE_BREAK = '\n'
 // `set -o pipefail` tells the shell to report the pipeline with the first failing command's status,
 // so nothing in it is discarded. The flag letters are loose because `set -eo pipefail` and
 // `set -euo pipefail` are the same instruction, and the `set` word is required so that a path or a
@@ -146,13 +156,37 @@ function leading_word(command: string): string {
 //
 // **A pipeline under `set -o pipefail` discards nothing**, so it is not this function's business —
 // answering otherwise would name the very form a caller is told to use instead.
+// A line outside a heredoc body is kept with its marker blanked, and a marker opens a body whose
+// delimiter is returned; inside one, every line is dropped through the line that is the delimiter alone.
+function open_heredoc(line: string, kept: Array<string>): string | undefined {
+	kept.push(line.replace(HEREDOC_MARKER, ' '))
+
+	return HEREDOC_MARKER.exec(line)?.[HEREDOC_DELIMITER_GROUP]
+}
+
+function close_heredoc(line: string, delimiter: string): string | undefined {
+	return line.trim() === delimiter ? undefined : delimiter
+}
+
+function without_heredoc_bodies(command: string): string {
+	const kept: Array<string> = []
+	const body: { delimiter?: string | undefined } = {}
+
+	for (const line of command.split(LINE_BREAK)) {
+		body.delimiter =
+			body.delimiter === undefined ? open_heredoc(line, kept) : close_heredoc(line, body.delimiter)
+	}
+
+	return kept.join(LINE_BREAK)
+}
+
 // Quoted text replaced by a space, which is what a reader walking into the middle of a chain has to
 // do before it can trust an operator it finds there. Exported because `time-writes.ts` needs the same
 // removal for a different reason — a quoted `sed` script holds `|` and slashes that read as a
 // pipeline and as paths — and two spellings of "remove the quotes" would disagree the first time one
 // of them learned about a quoting form the other did not.
 function unquoted(command: string): string {
-	return command.replaceAll(QUOTED_SPAN_PATTERN, ' ')
+	return without_heredoc_bodies(command).replaceAll(QUOTED_SPAN_PATTERN, ' ')
 }
 
 function discarded_commands(command: string): Array<string> {

package/scripts/version/fresh-metadata-cache.ts

@@ -0,0 +1,36 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+const CACHE_DIRECTORY_PREFIX = 'josh-latest-cache-'
+const CACHE_DIRECTORY_FLAG = '--config.cache-dir='
+
+// Points every stage at one metadata cache directory. pnpm keeps registry metadata there and the
+// package store elsewhere, so an empty one costs a metadata refetch, never a tarball download.
+function with_cache_directory(
+	stages: ReadonlyArray<ReadonlyArray<string>>,
+	cache_directory: string,
+): Array<Array<string>> {
+	return stages.map((stage) => [...stage, `${CACHE_DIRECTORY_FLAG}${cache_directory}`])
+}
+
+// A cached metadata file written through safe-chain lacks every version that was under 24 hours old
+// at the time, and with `minimumReleaseAge` set pnpm reuses a cache file younger than that age
+// instead of refetching it — so a version that has since aged in stays invisible for up to a day
+// (joshuafolkken/kit#2805). A fresh directory per run means nothing filtered earlier is ever read.
+function run_in_fresh_cache<T>(
+	stages: ReadonlyArray<ReadonlyArray<string>>,
+	run_stages: (stages: Array<Array<string>>) => T,
+): T {
+	const cache_directory = mkdtempSync(path.join(tmpdir(), CACHE_DIRECTORY_PREFIX))
+
+	try {
+		return run_stages(with_cache_directory(stages, cache_directory))
+	} finally {
+		rmSync(cache_directory, { recursive: true, force: true })
+	}
+}
+
+const fresh_metadata_cache = { with_cache_directory, run_in_fresh_cache }
+
+export { fresh_metadata_cache }

package/scripts/version/latest-update.ts

@@ -11,6 +11,7 @@ import { lockfile_overrides } from '#scripts/overrides/lockfile-overrides'
 import { overrides_files } from '#scripts/overrides/overrides-files'
 import { overrides_check } from '#scripts/overrides/overrides-logic'
 import { execaSync } from 'execa'
+import { fresh_metadata_cache } from './fresh-metadata-cache'
 import { latest_regression, type VersionRegression } from './latest-regression'
 import { preinstall_version_update } from './preinstall-version-update'
 
@@ -99,7 +100,7 @@ function find_regressions_after_update(snapshot: TreeSnapshot): Array<VersionReg
 // Exits zero: the tree is left exactly as it was found, nothing is broken, and every workflow that
 // runs `josh latest` in its preamble would otherwise stop for a situation that resolves itself.
 function update_without_downgrading(snapshot: TreeSnapshot): UpdateOutcome {
-	const status = run_update_stages(build_update_commands())
+	const status = fresh_metadata_cache.run_in_fresh_cache(build_update_commands(), run_update_stages)
 	if (status !== 0) return { status, is_rolled_back: false }
 
 	const regressions = find_regressions_after_update(snapshot)

package/scripts-ai/git-workflow.ts

@@ -5,6 +5,7 @@ import { git_commit } from '../scripts/git/git-commit'
 import { git_error } from '../scripts/git/git-error'
 import { git_issue, type IssueInfo } from '../scripts/git/git-issue'
 import { git_pr } from '../scripts/git/git-pr'
+import { git_preflight } from '../scripts/git/git-preflight'
 import { git_prompt, type WorkflowConfirmations } from '../scripts/git/git-prompt'
 import { git_push } from '../scripts/git/git-push'
 import { git_staging } from '../scripts/git/git-staging'
@@ -206,6 +207,14 @@ async function execute_workflow(
 	const { cli_issue_input, is_auto_mode, commit_suffix } = parse_positionals(positionals)
 	const is_non_interactive = is_non_interactive_mode(is_auto_mode, values)
 
+	// Unattended, nobody can fix a precondition between stages — so all are asked before staging.
+	if (is_non_interactive) {
+		await git_preflight.check({
+			cli_input: cli_issue_input,
+			will_open_pr: values['skip-pr'] !== true,
+		})
+	}
+
 	await git_staging.check_and_confirm_staging(values.yes === true)
 
 	const issue_info = await prepare_issue_info(cli_issue_input, is_non_interactive)
@@ -235,6 +244,7 @@ try {
 }
 
 const git_workflow = {
+	execute_workflow,
 	parse_positionals,
 	get_workflow_confirmations,
 	prepare_issue_info,

package/templates/CLAUDE.basic.md

@@ -0,0 +1,8 @@
+# Project instructions
+
+- 既存のファイルと利用者の設定を尊重し、変更する前に内容を確認する。
+- 変更には検証を付け、実行した結果を報告する。
+- HTML、CSS、JavaScript のファイルがある場合は Prettier で整形する。
+- 画面に見える変更をした場合はブラウザーで表示と操作を確認する。
+- JavaScript または TypeScript の動作を変更した場合は、その動作を確認する自動テストを追加する。
+- Git や GitHub を使う場合だけ、それぞれのワークフローを利用する。

package/templates/workflows/ci.yml

@@ -200,24 +200,45 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: pnpm install --frozen-lockfile --ignore-scripts
 
+      # A `basic` project has no `prepare`, no build and no SvelteKit, so the ordered steps below
+      # would fail on its first pull request (joshuafolkken/kit#2814). The profile is read from
+      # `josh profile` rather than re-derived here, and a basic project hands the whole check set to
+      # `josh gate`, which already decides per profile which checks apply. A `case` instead of a pipe
+      # into `grep -q`, for the `pipefail` reason given at `Detect E2E specs` below.
+      - name: Resolve project profile
+        id: profile
+        run: |
+          profile=$(pnpm --silent josh profile)
+          echo "${profile}"
+          case "${profile}" in
+            *'profile: basic ('*) echo 'is_basic=true' >> "$GITHUB_OUTPUT" ;;
+            *) echo 'is_basic=false' >> "$GITHUB_OUTPUT" ;;
+          esac
+
       - name: Run spell check
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm josh cspell:dot
 
       - name: Prepare
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm prepare
 
       - name: Run type check
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm exec svelte-kit sync && pnpm exec svelte-check --tsconfig ./tsconfig.json --threshold error
 
       - name: Run prettier check
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm exec prettier --check .
 
       # Build before eslint so generated outputs exist for type-aware linting.
       # The same build output is reused by the size check below.
       - name: Build
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm build
 
       - name: Run eslint check
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm exec eslint . --cache --cache-strategy content
 
       # Vitest browser-mode projects (*.svelte.test.ts) drive a real Playwright browser,
@@ -233,9 +254,15 @@ jobs:
         run: ./node_modules/.bin/playwright install --with-deps ${PLAYWRIGHT_BROWSERS}
 
       - name: Run unit tests
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm josh test:unit
 
+      - name: Run verification gate
+        if: steps.profile.outputs.is_basic == 'true'
+        run: pnpm josh gate --verbose
+
       - name: Check bundle size
+        if: steps.profile.outputs.is_basic != 'true'
         run: pnpm size-limit
 
   security:

package/scripts/rules/issue-bug-label.ts

@@ -1,85 +0,0 @@
-import { readFileSync } from 'node:fs'
-import path from 'node:path'
-import { issue_classification } from '#scripts/issue/issue-classification'
-import type { GuardRun } from '#scripts/josh/hook-decision'
-import { time_density_hook } from '#scripts/time-runtime/time-density-hook'
-import { time_shell } from '#scripts/time-runtime/time-shell'
-import { bash_triggers } from './bash-triggers'
-import { issue_filing_args } from './issue-filing-args'
-import { shell_segments } from './shell-segments'
-import { tail_commands } from './tail-commands'
-
-const LINT_NAMES = new Set(['issue:lint'])
-const LINT_PATH = /\b(?:issue:lint|iln)\s+(?:'([^']+)'|"([^"]+)"|(\S+))/u
-
-function lint_argument(segment: string): string | undefined {
-	const [, single_quoted, double_quoted, bare] = LINT_PATH.exec(segment) ?? []
-
-	return single_quoted ?? double_quoted ?? bare
-}
-
-function latest_lint_path(tail: string): string | undefined {
-	const segments = tail_commands
-		.prior_bash_commands(tail)
-		.flatMap((command) => shell_segments.segments_of(command))
-	const lint = segments.findLast((segment) => shell_segments.is_josh_command(segment, LINT_NAMES))
-
-	return lint === undefined ? undefined : lint_argument(lint)
-}
-
-function linted_body(body_path: string): string | undefined {
-	try {
-		return readFileSync(body_path, 'utf8')
-	} catch {
-		return undefined
-	}
-}
-
-function matches_linted_file(command: string, lint_path: string): boolean {
-	const filing_path = issue_filing_args.body_file(command)
-
-	return filing_path !== undefined && path.resolve(filing_path) === path.resolve(lint_path)
-}
-
-function needs_classification_labels(command: string, tail: string): boolean {
-	const lint_path = latest_lint_path(tail)
-
-	if (lint_path === undefined) return false
-	const body = linted_body(lint_path)
-
-	if (body === undefined) return false
-
-	if (!matches_linted_file(command, lint_path) || issue_classification.problems(body).length > 0) {
-		return true
-	}
-
-	const expected = issue_classification.required_labels(body)
-
-	return issue_classification.CLASSIFICATION_LABELS.some(
-		(label) => expected.includes(label) !== issue_filing_args.has_label(command, label),
-	)
-}
-
-function decide(call: { input: unknown }, run: GuardRun): boolean {
-	const command = time_shell.bash_command(call.input)
-	const tail = time_density_hook.read_tail(run.transcript)
-
-	return needs_classification_labels(command, tail)
-}
-
-const ISSUE_CLASSIFICATION_REASON =
-	'⛔ issue classification mismatch: use the exact body file checked by `pnpm josh issue:lint` ' +
-	'in this creation call (`-F body=@<path>` or `gh issue create --body-file <path>`) and ' +
-	'apply exactly the `labels:` it reports (`bug`, `enhancement`, `breaking-change`). See ' +
-	'`prompts/collaboration-workflow/issue-template.md`.'
-
-const ROW = {
-	id: 'issue-bug-label',
-	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-	reason: ISSUE_CLASSIFICATION_REASON,
-	decide,
-}
-
-const issue_bug_label_rule = { ROW, latest_lint_path, needs_classification_labels }
-
-export { issue_bug_label_rule }

package/scripts/rules/issue-filing-args.ts

@@ -1,50 +0,0 @@
-const SHELL_WORD = /(?:[^\s'"]|'[^']*'|"[^"]*")+/gu
-const QUOTE = /['"]/gu
-const RAW_FIELDS = new Set(['-f', '--raw-field'])
-const FILE_FIELDS = new Set(['-F', '--field'])
-const LABEL_OPTIONS = new Set(['-l', '--label'])
-const BODY_FILE_OPTIONS = new Set(['--body-file'])
-const INLINE_BODY_OPTIONS = new Set(['-b', '--body'])
-const BODY_FILE_PREFIX = 'body=@'
-
-function words_of(command: string): Array<string> {
-	return [...command.matchAll(SHELL_WORD)].map((match) => match[0].replaceAll(QUOTE, ''))
-}
-
-function values_after(words: ReadonlyArray<string>, flags: ReadonlySet<string>): Array<string> {
-	return words.flatMap((word, index) => {
-		const value = words[index + 1]
-
-		return value !== undefined && flags.has(word) ? [value] : []
-	})
-}
-
-function has_inline_body(words: ReadonlyArray<string>): boolean {
-	const has_raw = values_after(words, RAW_FIELDS).some((value) => value.startsWith('body='))
-
-	return has_raw || values_after(words, INLINE_BODY_OPTIONS).length > 0
-}
-
-function body_file(command: string): string | undefined {
-	const words = words_of(command)
-	const fields = values_after(words, FILE_FIELDS).filter((value) => value.startsWith('body='))
-	const options = values_after(words, BODY_FILE_OPTIONS)
-
-	if (has_inline_body(words) || fields.length + options.length !== 1) return undefined
-
-	return fields[0]?.startsWith(BODY_FILE_PREFIX)
-		? fields[0].slice(BODY_FILE_PREFIX.length)
-		: options[0]
-}
-
-function has_label(command: string, label: string): boolean {
-	const words = words_of(command)
-	const fields = [...values_after(words, RAW_FIELDS), ...values_after(words, FILE_FIELDS)]
-	const options = values_after(words, LABEL_OPTIONS).flatMap((value) => value.split(','))
-
-	return fields.includes(`labels[]=${label}`) || options.includes(label)
-}
-
-const issue_filing_args = { body_file, has_label, words_of }
-
-export { issue_filing_args }

package/scripts/rules/issue-scout.ts

@@ -1,64 +0,0 @@
-import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
-import { bash_triggers } from './bash-triggers'
-import { shell_segments } from './shell-segments'
-import { tail_commands } from './tail-commands'
-
-// The trigger and the delivered text behind the `issue-scout` row of `delivered-rules.ts`
-// (joshuafolkken/kit#2119).
-//
-// **A filing without `pnpm josh issue:scout` in front of it, refused at the filing itself.** §2e
-// requires the scout before every `gh api … issues` call, and a duplicate is likeliest for the work
-// that just finished — the one case self-restraint is least able to catch. The input is mechanical —
-// did the run already run the scout — so it is a delivered rule rather than resident prose.
-//
-// **It is `issue-comments`'s shape, not the WIP cap's.** Like that row it is once per run with an
-// `already_satisfied` stand-down read off the tail, and the refusal hands over the command rather than
-// asking the run to "scout first" — a body-only read is refused so the reissue makes the comments
-// present, and here a scout-less filing is refused so the reissue makes the scout present. **No new
-// delivery path**: the trigger is `bash_triggers.is_issue_filing`, reused verbatim.
-
-// `pnpm josh issue:scout`, the one act the rule asks for. The alias `isc` is expanded where the
-// command is read, so the canonical name matches both spellings (joshuafolkken/kit#1789).
-const SCOUT_NAMES: ReadonlySet<string> = new Set(['issue:scout'])
-
-// Keeping the rule: a call that runs the scout. Segment-wise, so a spelling quoted inside a filing's
-// own body is not read as the scout that filing skipped.
-function runs_the_scout(command: string): boolean {
-	return shell_segments
-		.segments_of(command)
-		.some((segment) => shell_segments.is_josh_command(segment, SCOUT_NAMES))
-}
-
-// The `already_satisfied` stand-down: the run has already scouted, so this filing asks for nothing new.
-// The tool-name gate the row's trigger applies has already passed, so `call` only marks the shape; the
-// answer is entirely in the tail.
-function already_scouted(tail: string, _call: GuardedCall): boolean {
-	return tail_commands.prior_bash_commands(tail).some((command) => runs_the_scout(command))
-}
-
-// The instruction in the shape a refusal can carry: what the call skipped, why it matters most here,
-// and the command that fixes it. The duplicate risk is named because it is the half that makes the
-// rule believable — the filing most likely to duplicate is the one about work that just finished.
-const ISSUE_SCOUT_REASON =
-	'⛔ issue scout: this files an Issue with no `pnpm josh issue:scout` earlier in the run. A ' +
-	'duplicate is likeliest for the work that just finished, which is exactly where self-restraint is ' +
-	'weakest. Reissue after scouting: `pnpm josh issue:scout "<title>"` (add `--body "<one-line ' +
-	'summary, citing #N where the work follows one>"` so the epic half can answer), then read its ' +
-	'`Duplicates:` — an **open** candidate covering the same work stops the run rather than filing a ' +
-	'second Issue, and a `(closed)` one means the work is already done — before reissuing this filing. ' +
-	'The procedure is `.claude/skills/workflow-commands/SKILL.md` → §2e. It fires once per run and ' +
-	'cannot repeat on the call in hand.'
-
-// 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 with the stand-down above.
-const ROW = {
-	id: 'issue-scout',
-	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-	reason: ISSUE_SCOUT_REASON,
-	already_satisfied: already_scouted,
-	keeps: bash_triggers.on_bash_command(runs_the_scout),
-}
-
-const issue_scout = { ISSUE_SCOUT_REASON, ROW, already_scouted, runs_the_scout }
-
-export { issue_scout }