@joshuafolkken/kit 1.872.0

package/scripts/init/init.ts

@@ -0,0 +1,219 @@
+#!/usr/bin/env tsx
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { resolve_local_bin } from '#scripts/build/local-bin'
+import { doctor_io } from '#scripts/doctor/doctor-io'
+import { package_version_schema, with_package_manager_schema } from '#scripts/lib/schemas'
+import { auto_merge_setting } from '#scripts/repo/auto-merge-setting'
+import { security_updates } from '#scripts/security/security-updates'
+import { did_refuse_self_run } from '#scripts/self-sync-guard/self-sync-refusal'
+import { sync } from '#scripts/sync/sync'
+import { package_manager_version } from '#scripts/version/package-manager-version'
+import { execaSync } from 'execa'
+import { init_actions, PRETTIER_CONFIG_JS, type FileAction } from './init-actions'
+import { init_ai_copy } from './init-ai-copy'
+import { init_logic } from './init-logic'
+import { PACKAGE_DIR, PROJECT_ROOT } from './init-paths'
+import { plugin_install_hint_module } from './plugin-install-hint'
+
+const PACKAGE_JSON = 'package.json'
+const KIT_PACKAGE_NAME = '@joshuafolkken/kit'
+const LEFTHOOK_BIN = 'lefthook'
+const SAMPLE_INDENT_WIDTH = 4
+const SAMPLE_INDENT = ' '.repeat(SAMPLE_INDENT_WIDTH)
+
+function write_new_file(action: FileAction, destination_path: string): void {
+	mkdirSync(path.dirname(destination_path), { recursive: true })
+	writeFileSync(destination_path, action.create())
+	console.info(`  ✔ created   ${action.dest}`)
+}
+
+function show_sample(action: FileAction): void {
+	console.info(`  ⚠ exists    ${action.dest} — add manually:`)
+	console.info('')
+	console.info(action.create().replaceAll(/^/gmu, () => SAMPLE_INDENT))
+}
+
+function merge_existing_file(
+	merge_function: (existing: string) => string,
+	destination_path: string,
+	destination: string,
+): void {
+	const existing = readFileSync(destination_path, 'utf8')
+	const merged = merge_function(existing)
+
+	if (merged === existing) {
+		console.info(`  ✔ unchanged ${destination}`)
+
+		return
+	}
+
+	writeFileSync(destination_path, merged)
+	console.info(`  ✔ updated   ${destination}`)
+}
+
+function execute_file_action(action: FileAction): void {
+	const destination_path = path.join(PROJECT_ROOT, action.dest)
+	const is_existing = existsSync(destination_path)
+
+	if (!is_existing) {
+		write_new_file(action, destination_path)
+
+		return
+	}
+
+	if (action.merge === undefined) {
+		show_sample(action)
+
+		return
+	}
+
+	merge_existing_file(action.merge, destination_path, action.dest)
+}
+
+function get_kit_package_manager(): string | undefined {
+	const { packageManager: package_manager } = with_package_manager_schema.parse(
+		init_actions.read_package_json(PACKAGE_JSON),
+	)
+
+	return package_manager !== undefined && package_manager.length > 0 ? package_manager : undefined
+}
+
+function get_kit_development_engines(): Record<string, unknown> {
+	return init_logic.get_development_engines_value()
+}
+
+// Pin the kit to its own published version so the generated configs (which all import
+// `@joshuafolkken/kit/...`) resolve. Exact pin matches the consumer convention.
+function get_kit_self_dependency(): Record<string, string> {
+	const { version } = package_version_schema.parse(init_actions.read_package_json(PACKAGE_JSON))
+
+	return { [KIT_PACKAGE_NAME]: version }
+}
+
+function apply_dependency_merges(content: string): string {
+	const migrated = init_logic.strip_managed_postinstall(content)
+	const merged = init_logic.merge_package_scripts(
+		migrated,
+		init_logic.get_suggested_scripts_for_content(migrated),
+	)
+	const with_prettier = init_logic.merge_prettier_plugin_development_deps(merged)
+	const with_secretlint = init_logic.merge_secretlint_development_deps(with_prettier)
+
+	return init_logic.merge_development_dependencies(with_secretlint, get_kit_self_dependency())
+}
+
+function apply_package_json_merges(content: string): string {
+	const with_kit = apply_dependency_merges(content)
+	const upgraded = init_logic.upgrade_prepare_lefthook_warning(with_kit)
+	const with_lifecycle = init_logic.merge_prepare_lifecycle_cmd(upgraded)
+	const kit_pm = get_kit_package_manager()
+	const with_pm =
+		kit_pm === undefined ? with_lifecycle : init_logic.merge_package_manager(with_lifecycle, kit_pm)
+	const with_de = init_logic.merge_development_engines(with_pm, get_kit_development_engines())
+	const sorted = init_logic.sort_package_json_keys(with_de)
+
+	// Pin devEngines.packageManager.version to the packageManager just written so a
+	// freshly scaffolded (or re-initialized) consumer never trips the pnpm
+	// dual-declaration warning.
+	return package_manager_version.align_development_engines_version(sorted)
+}
+
+function merge_project_package_json(): void {
+	const package_json_path = path.join(PROJECT_ROOT, PACKAGE_JSON)
+	if (!existsSync(package_json_path)) return
+
+	const existing = readFileSync(package_json_path, 'utf8')
+	const merged = apply_package_json_merges(existing)
+
+	if (merged === existing) {
+		console.info('  ✔ unchanged package.json')
+
+		return
+	}
+
+	writeFileSync(package_json_path, merged)
+	console.info('  ✔ updated   package.json')
+}
+
+function install_lefthook(): void {
+	console.info('\nLefthook:')
+	const bin = resolve_local_bin(PROJECT_ROOT, LEFTHOOK_BIN)
+	const result = execaSync(bin, ['install'], { cwd: PROJECT_ROOT, stdio: 'inherit', reject: false })
+
+	if (result.exitCode === undefined) {
+		console.warn('  ⚠ lefthook install failed — run it manually: lefthook install')
+	}
+}
+
+function run_config_file_actions(): void {
+	console.info('Config files:')
+
+	if (sync.migrate_prettierrc(path.join(PROJECT_ROOT, PRETTIER_CONFIG_JS))) {
+		console.info('  ✔ migrated  .prettierrc → prettier.config.js')
+	}
+
+	for (const action of init_actions.build_file_actions()) {
+		execute_file_action(action)
+	}
+}
+
+// Gated, unlike `sync`: `init` skips a file the consumer already has, so neither the npm-disable
+// (joshuafolkken/kit#803) nor the auto-merge workflow (joshuafolkken/kit#834) may have landed, and a
+// report's claim would then be false. `sync` overwrites both unconditionally, which is why it needs
+// no gate. The gates are the artifacts themselves, so a consumer's own pre-existing auto-merge
+// workflow still gets its prerequisite reported — it needs the same repository setting kit's does.
+function report_repository_settings(name_with_owner: string | undefined): void {
+	if (doctor_io.has_distributed_dependabot_config(PROJECT_ROOT, PROJECT_ROOT)) {
+		security_updates.report_security_updates_section(name_with_owner)
+	}
+
+	if (doctor_io.has_auto_merge_workflow(PROJECT_ROOT, PROJECT_ROOT)) {
+		auto_merge_setting.report_auto_merge_section(name_with_owner)
+	}
+}
+
+// The same refusal `sync` makes, for a larger blast radius: `init` calls the `sync` writers directly
+// rather than through `sync`'s own `main()`, so the guard there never ran for it — and on top of the
+// 14 files #868 reproduced, `init` also rewrites `package.json` scripts and devDependencies
+// (joshuafolkken/kit#879). Checked before the first write, for the reason the sync guard is.
+function run_ai_file_actions(): void {
+	console.info('\nAI files:')
+	// `init` writes the same npm-disabling `.github/dependabot.yml` that `sync` distributes, so a
+	// freshly scaffolded repository is exposed from its first commit — and a new private repository
+	// is exactly where the setting is off by default. The name is the one the Sonar config already
+	// resolved, so `gh repo view` runs once; the position is the pre-existing one.
+	const name_with_owner = init_ai_copy.run_ai_copies()
+
+	install_lefthook()
+
+	report_repository_settings(name_with_owner)
+
+	plugin_install_hint_module.report_plugin_install_hint()
+}
+
+function main(): void {
+	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return
+
+	console.info('\n🚀 Initializing @joshuafolkken/kit\n')
+	run_config_file_actions()
+
+	console.info('\nPackage scripts:')
+	merge_project_package_json()
+
+	run_ai_file_actions()
+	console.info('\n✅ Done.\n')
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) main()
+
+const init = {
+	copy_ai_file: init_ai_copy.copy_ai_file,
+	apply_package_json_merges,
+	install_lefthook,
+}
+
+// `init` is the entry point; `main` is exported for its own unit test, the way `sync.ts` exports the
+// `main()` its self-run guard lives in.
+export { init, main }

package/scripts/init/kit-base-preset.ts

@@ -0,0 +1,60 @@
+// Detect whether a consumer's managed-config list already references a `@joshuafolkken/*`
+// preset for a given subsystem (lefthook / cspell / tsconfig). Every ecosystem preset — kit's
+// own base as well as an app-kit / game-kit framework preset — embeds, extends, or imports kit
+// base by construction, so the presence of ANY such entry means kit base is already layered
+// exactly once. `josh sync` uses these predicates to avoid adding a SECOND kit-base reference
+// (which double-extends `lefthook/base.yml` into a hard recursion crash, and redundantly re-imports
+// the cspell / tsconfig base). Matching the consumer's own config content — not the dependency
+// tree — keeps the check source-of-truth-driven and free of any hardcoded package name.
+
+// A lefthook `extends` path such as `node_modules/@joshuafolkken/app-kit/lefthook/sveltekit.yml`
+// or `node_modules/@joshuafolkken/kit/lefthook/vanilla.yml`.
+const KIT_LEFTHOOK_PRESET = /@joshuafolkken\/[^/]+\/lefthook\//u
+// A cspell `import` value such as `@joshuafolkken/app-kit/cspell/sveltekit` or the bare base
+// `@joshuafolkken/kit/cspell` (hence the trailing `/`-or-end alternation).
+const KIT_CSPELL_PRESET = /@joshuafolkken\/[^/]+\/cspell(?:\/|$)/u
+// A tsconfig `extends` path such as `./node_modules/@joshuafolkken/app-kit/tsconfig/sveltekit.json`
+// or `./node_modules/@joshuafolkken/kit/tsconfig/base.json`. Extension-agnostic on purpose, so the
+// retired `.jsonc` form still matches and gets migrated rather than double-extended (#681).
+const KIT_TSCONFIG_PRESET = /@joshuafolkken\/[^/]+\/tsconfig\//u
+// A `*/sveltekit` framework preset referenced by an in-repo RELATIVE path that carries no
+// `@joshuafolkken/` prefix — the shape a self-hosting repo (app-kit's own repo) uses, e.g.
+// `./tsconfig/sveltekit.json`, `./cspell/sveltekit.yaml`, `lefthook/sveltekit.yml`. Such a preset
+// re-exports / inlines kit base by construction, so kit base must not be injected alongside it. The
+// KIT_*_PRESET regexes above only catch the installed-dependency form (`@joshuafolkken/…/sveltekit`);
+// this segment-anchored fallback covers the prefix-less relative form. The `(?<![\w-])` /
+// `(?![\w-])` boundaries anchor `sveltekit` to a complete path segment — mirroring app-kit's
+// config-patch anchoring — so a `sveltekit-*` / `*-sveltekit` sibling and hyphenated `svelte-kit`
+// are left untouched. See joshuafolkken/kit#664.
+const SVELTEKIT_PRESET = /(?<![\w-])sveltekit(?![\w-])/u
+
+function has_match(entries: ReadonlyArray<string>, pattern: RegExp): boolean {
+	return entries.some((entry) => pattern.test(entry))
+}
+
+// True when any entry references kit base for this subsystem (via a `@joshuafolkken/*` preset) or a
+// prefix-less `*/sveltekit` framework preset that re-exports it — either means kit base is already
+// layered exactly once, so `josh sync` must skip injecting a second base reference.
+function is_base_present(entries: ReadonlyArray<string>, subsystem_pattern: RegExp): boolean {
+	return has_match(entries, subsystem_pattern) || has_match(entries, SVELTEKIT_PRESET)
+}
+
+function is_lefthook_base_present(entries: ReadonlyArray<string>): boolean {
+	return is_base_present(entries, KIT_LEFTHOOK_PRESET)
+}
+
+function is_cspell_base_present(entries: ReadonlyArray<string>): boolean {
+	return is_base_present(entries, KIT_CSPELL_PRESET)
+}
+
+function is_tsconfig_base_present(entries: ReadonlyArray<string>): boolean {
+	return is_base_present(entries, KIT_TSCONFIG_PRESET)
+}
+
+const kit_base_preset = {
+	is_lefthook_base_present,
+	is_cspell_base_present,
+	is_tsconfig_base_present,
+}
+
+export { kit_base_preset }

package/scripts/init/plugin-install-hint.ts

@@ -0,0 +1,47 @@
+import { readdirSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { claude_plugin_config } from './claude-plugin-config'
+
+// `josh init` / `josh sync` declare the kit plugin in the consumer's `.claude/settings.json`, but the
+// CLI does not install it from the declaration alone — a consumer runs `claude plugin install kit@kit`
+// once (joshuafolkken/kit#1930). Nothing said so at the end of init or sync, so a consumer whose
+// skills silently never loaded had no pointer to the one command that fixes it. This prints that
+// command on completion, unless the plugin already appears installed.
+
+const PLUGINS_SUBDIR = path.join('.claude', 'plugins')
+
+// Best effort: Claude Code records installed marketplaces under `~/.claude/plugins`. The kit
+// marketplace directory being present is the strongest signal available at the shell; the plugin's
+// enabled state is not readable here, so an uncertain read (no directory, no permission) counts as
+// "not installed". A hint shown once too often costs a line; one never shown costs a consumer its skills.
+function is_plugin_installed(home_directory: string = os.homedir()): boolean {
+	try {
+		return readdirSync(path.join(home_directory, PLUGINS_SUBDIR)).some(
+			(entry) =>
+				entry === claude_plugin_config.MARKETPLACE_NAME ||
+				entry.startsWith(`${claude_plugin_config.MARKETPLACE_NAME}@`),
+		)
+	} catch {
+		return false
+	}
+}
+
+function plugin_install_hint(is_installed: boolean): string | undefined {
+	if (is_installed) return undefined
+
+	return `  ℹ Skills load from the kit plugin. If they are missing, run: claude plugin install ${claude_plugin_config.PLUGIN_ID}`
+}
+
+function report_plugin_install_hint(home_directory?: string): void {
+	const hint = plugin_install_hint(is_plugin_installed(home_directory))
+	if (hint !== undefined) console.info(hint)
+}
+
+const plugin_install_hint_module = {
+	is_plugin_installed,
+	plugin_install_hint,
+	report_plugin_install_hint,
+}
+
+export { plugin_install_hint_module }

package/scripts/init/tsconfig-preset-migration.ts

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { parse_jsonc } from '#scripts/config-merge/parse-jsonc'
+import { patch_json_key } from '#scripts/config-merge/patch-json-key'
+import { string_array_schema } from '#scripts/lib/schemas'
+
+// kit-family tsconfig presets used to ship with a `.jsonc` extension. Playwright (>= 1.62) appends
+// `.json` to any `extends` entry that does not already end in it and then hard-throws when the
+// resulting path is missing, so `…/tsconfig/base.jsonc` resolved to `…/tsconfig/base.jsonc.json`
+// and the entire E2E suite failed to start. (Before the throw was added the preset was simply never
+// applied, so the mis-resolution was silently wrong there too.) The presets are now shipped as
+// `*.json`; a consumer whose `extends` still points at the old path would never be repaired by the
+// ensure-based merge — an `@joshuafolkken/*` tsconfig entry is already present, so nothing is added
+// — hence the rewrite here. Scoped to `@joshuafolkken/*/tsconfig/*` paths so an unrelated
+// project-local `.jsonc` config is left alone. See joshuafolkken/kit#681.
+const LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u
+const LEGACY_SUFFIX = '.jsonc'
+const CURRENT_SUFFIX = '.json'
+
+// Single-sourced with init-logic-json-merge, which reads and patches the same field — a drift
+// between the key this module writes and the key that module reads would silently break the merge.
+const EXTENDS_FIELD = 'extends'
+
+// The rename lands package by package, so the `.json` preset may not exist yet in the version of
+// app-kit / game-kit the consumer has installed. Rewriting blindly would swap a path Playwright
+// cannot resolve for one `tsc` cannot resolve either — strictly worse. Rewriting only once the
+// target is actually on disk makes the migration order-independent: the entry stays untouched until
+// the package shipping it catches up, and the next sync repairs it.
+function is_migration_target_present(base_directory: string, entry: string): boolean {
+	return existsSync(path.resolve(base_directory, entry))
+}
+
+function migrate_entry(base_directory: string, entry: string): string {
+	if (!LEGACY_PRESET_ENTRY.test(entry)) return entry
+
+	const migrated = `${entry.slice(0, -LEGACY_SUFFIX.length)}${CURRENT_SUFFIX}`
+
+	return is_migration_target_present(base_directory, migrated) ? migrated : entry
+}
+
+// Preserve the authored shape: a string `extends` stays a string, an array stays an array.
+function migrate_extends_value(base_directory: string, raw: unknown): unknown {
+	if (typeof raw === 'string') return migrate_entry(base_directory, raw)
+
+	if (Array.isArray(raw)) {
+		return string_array_schema.parse(raw).map((entry) => migrate_entry(base_directory, entry))
+	}
+
+	return raw
+}
+
+// `base_directory` is the consumer project root the `extends` paths are relative to — the directory
+// holding the `tsconfig.json` being merged.
+function migrate_preset_paths(content: string, base_directory: string): string {
+	const parsed = parse_jsonc(content)
+	const raw = parsed[EXTENDS_FIELD]
+	const migrated = migrate_extends_value(base_directory, raw)
+	if (JSON.stringify(migrated) === JSON.stringify(raw)) return content
+
+	return patch_json_key.set_json_key(content, EXTENDS_FIELD, migrated)
+}
+
+const tsconfig_preset_migration = {
+	migrate_preset_paths,
+}
+
+export { EXTENDS_FIELD, tsconfig_preset_migration }

package/scripts/issue/baseline-measure.ts

@@ -0,0 +1,105 @@
+import { markdown_section } from './markdown-section'
+
+// A behavior-change Issue's baseline section is written as `command + value`, never prose, so that
+// `pnpm josh measure:rerun` can re-run the command after merge and print a before/after pair
+// (joshuafolkken/kit#2212). When the value has not moved, the premise the rule rested on is recorded
+// as refuted in the observation ledger — reusing that append-only mechanism rather than a second one.
+
+const BASELINE_HEADING = '## ベースライン'
+// `- `<command>` → <value>` (an ASCII `->` is accepted for the arrow). Prose with no backticked
+// command does not match, which is exactly how a natural-language measurement is rejected.
+const BASELINE_LINE = /^-\s*`([^`]+)`\s*(?:→|->)\s*(\S.*)$/u
+const VALUE_GROUP = 2
+
+const LEDGER_KEY_PREFIX = '- k:'
+const LEDGER_DEPTH = 'd1'
+const FIELD_SEPARATOR = ' | '
+// The ledger splits on ` | ` into exactly five fields, so free text may not carry that separator.
+const FIELD_SEPARATOR_REPLACEMENT = ' ; '
+const REMEASURE_COMMAND = 'pnpm josh measure:rerun'
+const NON_SLUG_RUN = /[^a-z0-9]+/gu
+// The key when a command has no alphanumerics to slug (e.g. an all-symbol shell expression); without it
+// the ledger key would be empty and the appended line would fail the ledger's own slug grammar.
+const EMPTY_SLUG_FALLBACK = 'baseline'
+
+interface Baseline {
+	command: string
+	value: string
+}
+
+function normalize(value: string): string {
+	return value.trim()
+}
+
+// Every `command + value` line under the baseline section; an empty array is a section written in
+// prose, which is the case the lint rejects.
+function parse_baselines(body: string): ReadonlyArray<Baseline> {
+	return markdown_section
+		.section_lines(body, BASELINE_HEADING)
+		.map((line) => BASELINE_LINE.exec(line.trim()))
+		.filter((match): match is RegExpExecArray => match !== null)
+		.map((match) => ({ command: match[1] ?? '', value: normalize(match[VALUE_GROUP] ?? '') }))
+}
+
+// A body carries a re-runnable baseline when at least one line parses to `command + value`.
+function has_command_value(body: string): boolean {
+	return parse_baselines(body).length > 0
+}
+
+// The value did not move between the recorded baseline and the re-measurement.
+function is_no_change(before: string, after: string): boolean {
+	return normalize(before) === normalize(after)
+}
+
+// The before/after pair for one baseline, printed under the command it was measured with.
+function format_pair(baseline: Baseline, after: string): string {
+	return [
+		`\`${baseline.command}\``,
+		`  before: ${normalize(baseline.value)}`,
+		`  after:  ${normalize(after)}`,
+	].join('\n')
+}
+
+function sanitize_field(text: string): string {
+	return text.split(FIELD_SEPARATOR).join(FIELD_SEPARATOR_REPLACEMENT).trim()
+}
+
+// `NON_SLUG_RUN` collapses every non-alphanumeric run to a single `-`, so the only empty segments a
+// split can produce are the leading and trailing ones; dropping them trims the edge dashes without a
+// second anchored regex.
+function slug_of(command: string): string {
+	const runs = command.toLowerCase().replaceAll(NON_SLUG_RUN, '-').split('-')
+	const slug = runs.filter(Boolean).join('-')
+
+	return slug === '' ? EMPTY_SLUG_FALLBACK : slug
+}
+
+// The observation-ledger line for a refuted premise, in the grammar
+// `- k:<slug> | d1 | <date> | <where> | <what>` (`observation-ledger-line.ts`). The key is derived
+// from the command, so a second refutation of the same measurement appends a same-key line and the
+// existing reappearance count sees it.
+function ledger_line(baseline: Baseline, date: string): string {
+	const what = sanitize_field(
+		`反証: ${baseline.command} は before/after とも ${normalize(baseline.value)}（変化なし）`,
+	)
+
+	return [
+		`${LEDGER_KEY_PREFIX}${slug_of(baseline.command)}`,
+		LEDGER_DEPTH,
+		date,
+		REMEASURE_COMMAND,
+		what,
+	].join(FIELD_SEPARATOR)
+}
+
+const baseline_measure = {
+	parse_baselines,
+	has_command_value,
+	is_no_change,
+	format_pair,
+	ledger_line,
+	slug_of,
+}
+
+export type { Baseline }
+export { baseline_measure }

package/scripts/issue/behavior-change-lint.ts

@@ -0,0 +1,122 @@
+import { firing_point } from '#scripts/rules/firing-point'
+import { baseline_measure } from './baseline-measure'
+import { markdown_section } from './markdown-section'
+import { reproduction_measure } from './reproduction-measure'
+
+// A behavior-change Issue owes three headings the ordinary template does not — a firing-point heading
+// (the tool call the rule breaks on), a baseline heading (a re-runnable measurement) and a
+// reproduction heading (the command and its actual output). This checks them, but only for an Issue
+// that declares itself one, and never asks the model to judge whether it is (joshuafolkken/kit#2212,
+// joshuafolkken/kit#2353). The declaration, the headings and the grammars are the template's, pinned
+// by the document test.
+
+// The body declares itself a behavior-change Issue with this exact line under its opening heading.
+// Read from the declaration, never inferred, so a code-only Issue is never held to the headings.
+const DECLARATION_LINE = '- 種別: 振る舞い変更'
+const FIRING_POINT_HEADING = '## 発火点'
+const BASELINE_HEADING = '## ベースライン'
+const REPRODUCTION_HEADING = '## 再現'
+const REQUIRED_HEADINGS: ReadonlyArray<string> = [
+	FIRING_POINT_HEADING,
+	BASELINE_HEADING,
+	REPRODUCTION_HEADING,
+]
+
+// A template placeholder line — the `<...>` guidance a filed Issue replaces. It is not a firing point.
+const PLACEHOLDER_PREFIX = '<'
+const BACKTICKED = /`([^`]+)`/u
+const WHITESPACE = /\s+/u
+// A leading Markdown bullet marker (`- ` / `* `), stripped before the firing-point token is read so a
+// bulleted line (`- Bash`) yields `Bash` rather than the dash.
+const BULLET_MARKER = /^[-*]\s+/u
+
+// Whether the body declares itself a behavior-change Issue.
+function is_target(body: string): boolean {
+	return markdown_section.has_line(body, DECLARATION_LINE)
+}
+
+// The required headings a behavior-change body lacks, in template order.
+function missing_headings(body: string): ReadonlyArray<string> {
+	return REQUIRED_HEADINGS.filter((heading) => !markdown_section.has_line(body, heading))
+}
+
+function is_content(line: string): boolean {
+	return line.length > 0 && !line.startsWith(PLACEHOLDER_PREFIX)
+}
+
+function first_content_line(lines: ReadonlyArray<string>): string | undefined {
+	return lines.map((line) => line.trim()).find((line) => is_content(line))
+}
+
+// The tool call name written under the firing-point heading, or undefined when the section names none.
+// A backticked token wins (`` `Bash` ``); otherwise a leading bullet marker is stripped and the first
+// whitespace-delimited word is taken, so both `Bash` and `- Bash` yield `Bash`.
+function firing_point_name(body: string): string | undefined {
+	const line = first_content_line(markdown_section.section_lines(body, FIRING_POINT_HEADING))
+
+	if (line === undefined) return undefined
+
+	return BACKTICKED.exec(line)?.[1] ?? line.replace(BULLET_MARKER, '').split(WHITESPACE, 1)[0]
+}
+
+function firing_point_problem(body: string): string | undefined {
+	const name = firing_point_name(body)
+
+	if (name === undefined) return undefined
+
+	if (firing_point.classify(name) === 'not-delivered') {
+		return `firing point \`${name}\` is a real tool call, but no hook can deliver a rule on it`
+	}
+
+	if (firing_point.classify(name) === 'unknown') {
+		return `firing point \`${name}\` is not on the delivery table (not a recognized tool call)`
+	}
+
+	return undefined
+}
+
+function baseline_problem(body: string): string | undefined {
+	if (!markdown_section.has_line(body, BASELINE_HEADING)) return undefined
+
+	if (baseline_measure.has_command_value(body)) return undefined
+
+	return 'baseline must be written as `command → value`, not prose (it has to be re-runnable)'
+}
+
+// The reproduction section is checked for format only where the heading is present — a missing heading
+// is already reported by `heading_problems`, so reporting it here too would double the message.
+function reproduction_problem(body: string): string | undefined {
+	if (!markdown_section.has_line(body, REPRODUCTION_HEADING)) return undefined
+
+	if (reproduction_measure.has_command_output(body)) return undefined
+
+	return 'reproduction must be a command and its actual output (a fenced block), not prose ("確認した" is not re-runnable)'
+}
+
+function heading_problems(body: string): ReadonlyArray<string> {
+	return missing_headings(body).map((heading) => `missing heading: ${heading}`)
+}
+
+// Every behavior-change problem a body has, or an empty array. A body that does not declare itself a
+// behavior-change Issue has none — the headings are not required of it.
+function problems(body: string): ReadonlyArray<string> {
+	if (!is_target(body)) return []
+
+	return [
+		...heading_problems(body),
+		firing_point_problem(body),
+		baseline_problem(body),
+		reproduction_problem(body),
+	].filter((problem): problem is string => problem !== undefined)
+}
+
+const behavior_change_lint = {
+	is_target,
+	missing_headings,
+	firing_point_name,
+	problems,
+	REQUIRED_HEADINGS,
+	DECLARATION_LINE,
+}
+
+export { behavior_change_lint }