@joshuafolkken/kit 1.1435.0 → 1.1455.0

package/scripts/auto-ok/auto-ok-judge-write.ts

@@ -0,0 +1,109 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_label_schema } from '#scripts/git/git-schemas'
+import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
+import { issue_auto_ok, type AutoOkDecision } from '#scripts/issue/issue-auto-ok'
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { AUTO_OK_LABEL } from '#scripts/issue/issue-labels'
+import { session_cite } from '#scripts/issue/session-cite'
+import { run_event_stream } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { z } from 'zod'
+import { auto_ok_judge } from './auto-ok-judge'
+
+// The writing half of `josh auto-ok:judge`: the agent's judgement of one open issue, recorded on it.
+//
+// **An applied judgement still passes the mechanical exclusions** — `issue_auto_ok.exclusion_of` is
+// re-read against the labels as they stand, so a label added since the listing refuses the write
+// rather than racing it. **The run label lands before `auto-ok`**, so the pool never holds an opted-in
+// issue that `backlog:next` would withhold as untriaged. Both answers leave the judgement comment the
+// next listing reads as the record, and an applied one is a `note` on the board's 📌.
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const UNREADABLE = 'the issue could not be read'
+
+const issue_schema = z.object({ labels: z.array(issue_label_schema), body: z.string().nullish() })
+
+interface IssueRead {
+	labels: ReadonlyArray<string>
+	body: string
+}
+
+async function read_issue(issue: string): Promise<IssueRead | undefined> {
+	const raw = await git_gh_command.issue_get_labels_and_body(issue)
+	const parsed = raw === undefined ? undefined : parse_json_object_or_undefined(raw, issue_schema)
+
+	if (parsed === undefined) return undefined
+
+	return { labels: parsed.labels.map((label) => label.name), body: parsed.body ?? '' }
+}
+
+async function apply_labels(issue: string, run_label: string): Promise<string | undefined> {
+	for (const label of [run_label, AUTO_OK_LABEL]) {
+		// eslint-disable-next-line no-await-in-loop -- the run label must land before `auto-ok`
+		const write = await git_gh_command.issue_apply_label(issue, label)
+
+		if (!write.is_applied) return `could not apply \`${label}\`: ${write.reason}`
+	}
+
+	return undefined
+}
+
+async function record(issue: string, decision: AutoOkDecision, body: string): Promise<number> {
+	try {
+		await git_gh_command.issue_comment(issue, auto_ok_judge.comment_of(decision, body))
+	} catch {
+		console.error(`could not comment the judgement on ${session_cite.issue(issue)}`)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(issue_auto_ok.line_of(decision))
+
+	return SUCCESS_EXIT_CODE
+}
+
+function refused(issue: string, problem: string): number {
+	console.error(`${session_cite.issue(issue)}: ${problem}`)
+
+	return FAILURE_EXIT_CODE
+}
+
+async function apply_to(issue: string, run_label: string, read: IssueRead): Promise<number> {
+	const exclusion = issue_auto_ok.exclusion_of(read.labels)
+
+	if (exclusion !== undefined) return refused(issue, issue_auto_ok.line_of(exclusion))
+
+	const problem = await apply_labels(issue, run_label)
+
+	if (problem !== undefined) return refused(issue, problem)
+
+	const reason = `judged by backlogrun: no exclusion holds and no person's judgement is needed (${run_label})`
+
+	await run_event_stream_emit.emit(
+		run_event_stream.EVENT_KIND.NOTE,
+		`${issue_cite.plain(issue)} auto-ok applied (${run_label})`,
+	)
+
+	return await record(issue, { is_applied: true, reason }, read.body)
+}
+
+async function apply(issue: string, run_label: string): Promise<number> {
+	const read = await read_issue(issue)
+
+	if (read === undefined) return refused(issue, UNREADABLE)
+
+	return await apply_to(issue, run_label, read)
+}
+
+async function decline(issue: string, reason: string): Promise<number> {
+	const read = await read_issue(issue)
+
+	if (read === undefined) return refused(issue, UNREADABLE)
+
+	return await record(issue, { is_applied: false, reason }, read.body)
+}
+
+const auto_ok_judge_write = { apply, decline }
+
+export { auto_ok_judge_write }

package/scripts/auto-ok/auto-ok-judge.ts

@@ -0,0 +1,67 @@
+import { createHash } from 'node:crypto'
+import { issue_auto_ok, type AutoOkDecision } from '#scripts/issue/issue-auto-ok'
+import { AUTO_OK_LABEL, has_label_name } from '#scripts/issue/issue-labels'
+import type { WatchComment } from '#scripts/issue/issue-watch-diff'
+
+// The pure half of `josh auto-ok:judge`: which open issues `backlogrun` judges for `auto-ok` when a lane
+// is free and nothing is opted in, and whether one was already judged (joshuafolkken/kit#3854).
+//
+// **The mechanical exclusions are `issue_auto_ok.exclusion_of`**, the list a filing is judged by
+// (joshuafolkken/kit#3853), never a second one. What a label cannot answer — whether a policy decision,
+// an external account or a human visual check is needed — is the agent's reading of the body and the
+// comments, so this module only says which issues still owe that reading.
+//
+// **The record is the judgement comment itself.** It carries a digest of the body it judged, so an
+// issue is judged again only when its body changed or a person commented after it — the same line
+// `issue_watch_diff` draws between a person's update and an automated one.
+
+interface JudgeIssue {
+	number: number
+	labels: ReadonlyArray<string>
+	body: string
+}
+
+const MARKER_PREFIX = '<!-- josh:auto-ok-judged body='
+const MARKER_SUFFIX = ' -->'
+const MARKER_PATTERN = /<!-- josh:auto-ok-judged body=(?<digest>[\da-f]+) -->/u
+const DIGEST_LENGTH = 16
+const CRLF = '\r\n'
+const LF = '\n'
+
+function is_candidate(issue: JudgeIssue): boolean {
+	if (has_label_name(issue.labels, AUTO_OK_LABEL)) return false
+
+	return issue_auto_ok.exclusion_of(issue.labels) === undefined
+}
+
+// GitHub stores a body saved in its web editor with CRLF, so the digest is taken over LF alone.
+function body_digest(body: string): string {
+	const normalized = body.split(CRLF).join(LF)
+
+	return createHash('sha256').update(normalized).digest('hex').slice(0, DIGEST_LENGTH)
+}
+
+function digest_of(comment: WatchComment): string | undefined {
+	return MARKER_PATTERN.exec(comment.body)?.groups?.['digest']
+}
+
+// Judged when the newest judgement comment covers the body as it stands and no person has commented
+// since. A failed comment read never reaches here — the caller treats it as nothing learned.
+function is_judged(body: string, comments: ReadonlyArray<WatchComment>): boolean {
+	const judgement = comments.findLast((comment) => digest_of(comment) !== undefined)
+
+	if (judgement === undefined || digest_of(judgement) !== body_digest(body)) return false
+
+	return comments.every((comment) => comment.id <= judgement.id || comment.is_automated)
+}
+
+function comment_of(decision: AutoOkDecision, body: string): string {
+	const marker = `${MARKER_PREFIX}${body_digest(body)}${MARKER_SUFFIX}`
+
+	return `${issue_auto_ok.line_of(decision)}${LF}${LF}${marker}`
+}
+
+const auto_ok_judge = { comment_of, is_candidate, is_judged }
+
+export type { JudgeIssue }
+export { auto_ok_judge }

package/scripts/backlog/backlog-drive-cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 import { setTimeout as sleep } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
+import { auto_ok_judge_read, type JudgedCache } from '#scripts/auto-ok/auto-ok-judge-read'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { josh_command } from '#scripts/josh/josh-run'
@@ -166,6 +167,18 @@ function end_line(end: DriveEnd): string {
 	return end.detail === undefined ? base : `${base} ${end.detail}`
 }
 
+// The count of open issues owing an `auto-ok` judgement, over a cache kept for the process so a watch
+// minute reads the comments only of the issues that moved (`auto-ok-judge-read.ts`).
+function judgement_reader(): () => Promise<number> {
+	const cache: JudgedCache = new Map()
+
+	return async () => {
+		const owed = await auto_ok_judge_read.owed(cache)
+
+		return owed?.length ?? 0
+	}
+}
+
 function ports_of(
 	context: DriveContext,
 	seeded: ReadonlyArray<string>,
@@ -177,6 +190,7 @@ function ports_of(
 		offer: async (state) => await read_offer(state, context),
 		launch: async (issue) => await backlog_drive_launch.launch(issue, context.owner),
 		free_lanes: backlog_ready.drive_free_lane_count,
+		judgement_owed: judgement_reader(),
 		now: () => new Date(),
 		sleep: async (milliseconds) => {
 			await sleep(milliseconds)

package/scripts/backlog/backlog-drive.ts

@@ -65,6 +65,8 @@ const KNOWN_VERDICTS: ReadonlySet<string> = new Set([
 ])
 const NO_RETRIES = 0
 const NO_FREE_LANES = 0
+const EXHAUSTED_ANSWER = 'exhausted'
+const JUDGE_REASON = 'judge'
 const LAUNCHED = 'launched'
 const UNOPENED = 'unopened'
 
@@ -98,7 +100,8 @@ interface DriveState {
 }
 
 interface DriveEnd {
-	// Why the loop handed control back: `merge`, `launch`, `offer`, `watch`, `stop`, `window` or a verdict.
+	// Why the loop handed control back: `merge`, `launch`, `offer`, `judge`, `watch`, `stop`, `window`
+	// or a verdict.
 	reason: string
 	// The token the parent reads, where one command printed it.
 	token: string | undefined
@@ -121,6 +124,9 @@ interface DrivePorts {
 	// The lanes free right now — `backlog_ready.drive_free_lane_count` in production, the limit less the
 	// open lanes.
 	free_lanes: () => Promise<number>
+	// How many open issues lacking `auto-ok` still owe a judgement — `auto_ok_judge_read.owed` in
+	// production, `0` when the read failed.
+	judgement_owed: () => Promise<number>
 	now: () => Date
 }
 
@@ -149,7 +155,7 @@ function ended(reason: string, state: DriveState, token?: string, issue?: string
 function is_drain(read: OfferRead, state: DriveState): boolean {
 	return (
 		read.verdict === WATCH_VERDICT &&
-		read.answer === 'exhausted' &&
+		read.answer === EXHAUSTED_ANSWER &&
 		state.in_flight.length === 0 &&
 		read.is_retrospective_owed === true
 	)
@@ -158,7 +164,7 @@ function is_drain(read: OfferRead, state: DriveState): boolean {
 function needs_retrospective(read: OfferRead, state: DriveState): boolean {
 	return (
 		read.verdict === STOP_VERDICT &&
-		read.answer === 'exhausted' &&
+		read.answer === EXHAUSTED_ANSWER &&
 		state.in_flight.length === 0 &&
 		read.is_retrospective_owed === true
 	)
@@ -318,6 +324,18 @@ function on_verdict(read: OfferRead, state: DriveState): PassResult {
 	return { kind: 'continue', state }
 }
 
+// **A free lane with nothing opted in is the open backlog's turn to be judged**
+// (joshuafolkken/kit#3854): a watch over an exhausted pool hands back `judge` while an open issue
+// lacking `auto-ok` still owes a judgement, ahead of the drain it would otherwise be. Once every one
+// carries its judgement comment the count is zero and the watch is the driver's again.
+async function is_judgement_owed(read: OfferRead, ports: DrivePorts): Promise<boolean> {
+	const is_exhausted = read.verdict === WATCH_VERDICT && read.answer === EXHAUSTED_ANSWER
+
+	if (!is_exhausted || (await ports.free_lanes()) <= NO_FREE_LANES) return false
+
+	return (await ports.judgement_owed()) > 0
+}
+
 async function ask_offer(state: DriveState, ports: DrivePorts): Promise<PassResult> {
 	const read = await ports.offer(state)
 
@@ -326,6 +344,7 @@ async function ask_offer(state: DriveState, ports: DrivePorts): Promise<PassResu
 	const next = { ...state, retries: read.retries }
 
 	if (read.verdict === RUN_VERDICT) return await launch_all(read.issues, next, ports)
+	if (await is_judgement_owed(read, ports)) return ended(JUDGE_REASON, next, JUDGE_REASON)
 
 	return on_verdict(read, next)
 }

package/scripts/document/document-byte-budget.ts

@@ -76,7 +76,7 @@ const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
 	{ path: 'docs/josh-commands-automation.md', bytes: 53_248 },
 	{ path: 'docs/josh-commands-run.md', bytes: 77_824 },
 	{ path: 'docs/josh-commands-backlog.md', bytes: 61_440 },
-	{ path: 'docs/josh-commands.md', bytes: 53_248 },
+	{ path: 'docs/josh-commands.md', bytes: 57_344 },
 	{ path: 'docs/labels-and-run-states.md', bytes: 8192 },
 	{ path: 'prompts/coding-standards.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow.md', bytes: 8192 },

package/scripts/fresh-machine/fresh-machine-patterns.ts

@@ -27,13 +27,18 @@ const INIT_COMMANDS = [INSTALL_TARBALL, 'pnpm exec josh init', GATE]
 // `josh start` leaves the project on its setup branch, where the gate asks for the scoped checks
 // first; this is the line its refusal hands back.
 const SCOPED_CHECKS = 'pnpm josh lint:related && pnpm josh test:related'
-const START_COMMANDS = [
-	EXCLUDE_RELEASE_AGE,
-	INSTALL_PUBLISHED,
-	'pnpm exec josh start --yes --github',
-	SCOPED_CHECKS,
-	GATE,
-]
+const START = 'pnpm exec josh start --yes --github'
+
+// An agent names the profile rather than leaving it to detection, so every pattern passes its own.
+function start_commands(profile: string): Array<string> {
+	return [
+		EXCLUDE_RELEASE_AGE,
+		INSTALL_PUBLISHED,
+		`${START} --profile ${profile}`,
+		SCOPED_CHECKS,
+		GATE,
+	]
+}
 
 // `gh auth login` cannot run without a person, and it is what points git at gh for credentials; with
 // the token in the environment this is the same step.
@@ -49,6 +54,11 @@ const FIRST_COMMIT = [
 	'git add --all && git commit --message "Initial commit"',
 ]
 const CREATE_REPOSITORY = 'gh repo create "$RUN_NAME" --private --source . --push'
+// The labels a repository already had, recorded before `josh start` so the probe after it shows none
+// was removed or changed.
+const LABELS = 'gh label list --limit 100'
+// The setup pull request's CI, waited for and recorded; the pull request itself is never merged.
+const SETUP_CI = 'gh pr checks --watch --interval 60'
 
 // The two states #3712 was found in: a shell that reads no rc file, and a PATH with `node` on it and
 // no `pnpm`.
@@ -60,13 +70,29 @@ const PATH_PROBES = [
 	`mkdir -p ${NODE_ONLY} && ln -sf "$(command -v node)" ${NODE_ONLY}/node && ${BARE_SHELL} 'PATH="$HOME/node-only:$PATH" ./node_modules/.bin/josh gate'`,
 ]
 
+// What a `josh start` run is checked against before the PATH states: the profile it recorded, the
+// repository's visibility and branch, its labels, and the files the first commit on `main` holds. Where
+// `main` already had a commit, `josh start` opens a setup Issue and pull request instead of pushing to
+// it; the last four record those, the files the pull request carries and the `main` GitHub holds.
+const PROFILE = 'pnpm josh profile'
+const START_PROBES = [
+	PROFILE,
+	'gh repo view --json visibility,defaultBranchRef',
+	LABELS,
+	'git show --name-only --format= "$(git rev-list --max-parents=0 main)"',
+	'gh issue list --state all --json number,title,state,labels',
+	'gh pr list --state all --json number,title,state,headRefName,labels,closingIssuesReferences',
+	'gh pr diff --name-only',
+	'git log --oneline origin/main',
+]
+
 // What a `josh init` run is checked against after the gate: the profile it chose, the files it left
 // (a `./.git` line is a repository it should not have made), and a second run that changes nothing.
 const PROJECT_FILES =
 	'find . -name node_modules -prune -o -name .git -prune -o -type f -print | sort'
 const CHECKSUMS = `${PROJECT_FILES} | xargs sha256sum`
 const INIT_PROBES = [
-	'pnpm josh profile',
+	PROFILE,
 	'find . -name node_modules -prune -o -print | sort',
 	`${CHECKSUMS} > "$HOME/before-second-init.sha" && pnpm exec josh init && ${CHECKSUMS} | diff "$HOME/before-second-init.sha" -`,
 ]
@@ -90,31 +116,50 @@ function init_pattern(
 	})
 }
 
+// What a `josh start` pattern adds to the shared steps: the state before the install, the profile it
+// names, the commands that must pass after the gate, and the probes recorded before the PATH states.
+interface StartProject {
+	setup: ReadonlyArray<string>
+	profile: string
+	checks?: ReadonlyArray<string>
+	probes?: ReadonlyArray<string>
+}
+
 function start_pattern(
 	project: string,
 	files: Record<string, string>,
-	setup: ReadonlyArray<string>,
+	{ setup, profile, checks = [], probes = [] }: StartProject,
 ): Scenario {
 	return fresh_machine_spec.define({
 		name: `kit-test-${project}-start`,
 		requires_github: true,
 		package_source: 'published',
 		files,
-		commands: [SIGN_IN, ...setup, ...START_COMMANDS],
-		probes: PATH_PROBES,
+		commands: [SIGN_IN, ...setup, ...start_commands(profile), ...checks],
+		probes: [...START_PROBES, ...probes, ...PATH_PROBES],
 	})
 }
 
 const PATTERNS: ReadonlyArray<Scenario> = [
 	init_pattern('lua', LUA_FILES, [BARE_MANIFEST]),
 	// No Git: `josh start` creates the repository, the first commit and the GitHub repository.
-	start_pattern('lua', LUA_FILES, [MACHINE_IDENTITY, BARE_MANIFEST]),
+	start_pattern('lua', LUA_FILES, { setup: [MACHINE_IDENTITY, BARE_MANIFEST], profile: 'basic' }),
 	init_pattern('html', HTML_FILES, [BARE_MANIFEST]),
 	// Git with a first commit on `main`, no GitHub repository.
-	start_pattern('html', HTML_FILES, [...FIRST_COMMIT, BARE_MANIFEST]),
+	start_pattern('html', HTML_FILES, { setup: [...FIRST_COMMIT, BARE_MANIFEST], profile: 'basic' }),
 	init_pattern('svelte', {}, [CREATE_SVELTEKIT, SV_VERSION, SVELTEKIT_CHECKS], [SVELTEKIT_CHECKS]),
-	// A GitHub repository with `main` already pushed.
-	start_pattern('svelte', {}, [CREATE_SVELTEKIT, ...FIRST_COMMIT, CREATE_REPOSITORY]),
+	// A GitHub repository with `main` already pushed, its labels recorded before the install; the app
+	// still builds and type-checks on the setup branch, and the setup pull request's CI is waited for.
+	start_pattern(
+		'svelte',
+		{},
+		{
+			setup: [CREATE_SVELTEKIT, SV_VERSION, ...FIRST_COMMIT, CREATE_REPOSITORY, LABELS],
+			profile: 'full',
+			checks: [SVELTEKIT_CHECKS],
+			probes: [SETUP_CI],
+		},
+	),
 ]
 
 function names(): Array<string> {

package/scripts/gate/project-checks.ts

@@ -2,6 +2,7 @@ import { existsSync, globSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { find_local_bin_upwards } from '#scripts/build/local-bin'
 import { doctor_consumer } from '#scripts/doctor/doctor-consumer'
+import { own_formatter } from '#scripts/init/own-formatter'
 import { project_profile } from '#scripts/init/project-profile'
 import { ancestor_directories } from '#scripts/lib/ancestor-directories'
 import { json_value } from '#scripts/lib/json-value'
@@ -150,10 +151,12 @@ function type_check_skip_reason(directory: string): string | undefined {
 }
 
 // Shared by `josh lint`, `josh lint:related` and `josh format`, so a basic project without Web
-// files — a Python or Rust project, which `josh init` gives no Prettier — is skipped for the same
-// reason by all three.
+// files — a Python or Rust project, which `josh init` gives no Prettier — or with a formatter of its
+// own is skipped for the same reason by all three.
 function prettier_skip_reason(directory: string): string | undefined {
 	if (!is_basic(directory)) return undefined
+	const formatter = own_formatter.find_config(project_root(directory))
+	if (formatter !== undefined) return `${formatter} configures the project's own formatter`
 	if (!has_files(directory, WEB_FILES)) return 'no HTML, CSS or JavaScript files were found'
 
 	return missing_tool_reason(directory, 'prettier', 'prettier')

package/scripts/gh/git-gh-issue-rest.ts

@@ -71,6 +71,7 @@ const REST_FIELD_NAMES = new Map<string, string>([
 	['url', 'html_url'],
 	['createdAt', 'created_at'],
 	['closedAt', 'closed_at'],
+	['updatedAt', 'updated_at'],
 ])
 
 const NOT_AN_ISSUE_MESSAGE = 'gh api answered something other than an issue object'

package/scripts/gh/git-gh-issue.ts

@@ -150,6 +150,14 @@ async function issue_list_by_label_in_repo(
 	return await issue_list({ json_fields: SUMMARY_FIELDS, limit, label, repo })
 }
 
+// Every open issue with what `josh auto-ok:judge` judges it by — its labels and body — and `updatedAt`,
+// so the backlog driver's resident check reads an issue's comments again only once it has moved.
+const JUDGEMENT_FIELDS = 'number,title,body,labels,updatedAt'
+
+async function issue_list_open_for_judgement(limit: number): Promise<IssueListOutcome> {
+	return await issue_list({ json_fields: JUDGEMENT_FIELDS, limit })
+}
+
 const git_gh_issue = {
 	...git_gh_issue_read,
 	...git_gh_issue_write,
@@ -159,6 +167,7 @@ const git_gh_issue = {
 	issue_list_by_label_summary,
 	issue_search_body,
 	issue_list_open_bodies,
+	issue_list_open_for_judgement,
 	issue_list_recently_closed,
 }
 

package/scripts/gh/git-pr-ai-review.ts

@@ -89,6 +89,10 @@ async function fetch_review_comments(
 	return parsed?.map((comment) => to_review_comment(comment))
 }
 
+// The other choice both AI-review stops offer: a person who has looked records why and moves on.
+const IGNORE_ALTERNATIVE =
+	'Re-run `pnpm josh followup --ai-review-ignore-reason "<reason>"` if the gate does not apply'
+
 async function handle_blockers(input: {
 	branch_name: string
 	ignore_reason: string | undefined
@@ -105,7 +109,12 @@ async function handle_blockers(input: {
 		return
 	}
 
-	await git_pr_confirmation.notify_confirmation({ context: input.context, body })
+	await git_pr_confirmation.notify_confirmation({
+		context: input.context,
+		body,
+		recommended: 'Fix the findings and re-run `pnpm josh followup`',
+		alternatives: [IGNORE_ALTERNATIVE],
+	})
 
 	throw new Error(body)
 }
@@ -140,6 +149,8 @@ async function handle_unreadable_comments(input: {
 	await git_pr_confirmation.notify_confirmation({
 		context: input.context,
 		body: UNREADABLE_COMMENTS_BODY,
+		recommended: 'Re-run `pnpm josh followup` once the comments can be read',
+		alternatives: [IGNORE_ALTERNATIVE],
 	})
 
 	throw new Error(UNREADABLE_COMMENTS_BODY)

package/scripts/gh/git-pr-confirmation.ts

@@ -1,3 +1,7 @@
+import {
+	confirmation_options,
+	type ConfirmationOptions,
+} from '#scripts/notify/confirmation-options'
 import { telegram_notify, type TelegramSendInput } from '#scripts/notify/telegram-notify'
 
 // What to type when the confirmation notification itself could not be delivered.
@@ -5,7 +9,7 @@ import { telegram_notify, type TelegramSendInput } from '#scripts/notify/telegra
 // commands and a backtick inside shell double quotes is evaluated before the command runs.
 const CONFIRMATION_RECOVERY =
 	'send it by hand — `pnpm josh notify --task-type confirmation --issue-url <url> ' +
-	'--body-file <path>`'
+	'--body-file <path> --recommended "<choice>"`'
 
 interface TelegramContext {
 	repo_name: string | undefined
@@ -14,15 +18,18 @@ interface TelegramContext {
 	pr_url: string | undefined
 }
 
-function build_confirmation_input(input: {
+interface ConfirmationInput extends ConfirmationOptions {
 	context: TelegramContext
 	body: string
-}): TelegramSendInput {
+}
+
+function build_confirmation_input(input: ConfirmationInput): TelegramSendInput {
 	return {
 		task_type: 'confirmation',
 		repo_name: input.context.repo_name,
 		issue_title: input.context.issue_title,
 		body: input.body,
+		choices: confirmation_options.block(input),
 		issue_url: input.context.issue_url,
 		pr_url: input.context.pr_url,
 	}
@@ -34,10 +41,7 @@ function build_confirmation_input(input: {
 //
 // Unlike the completion notification, this one *has* a recovery: a `confirmation` is exactly what
 // `josh notify` is for, and the run stops here anyway, so re-sending it by hand loses nothing.
-async function notify_confirmation(input: {
-	context: TelegramContext
-	body: string
-}): Promise<void> {
+async function notify_confirmation(input: ConfirmationInput): Promise<void> {
 	await telegram_notify.send_or_report(build_confirmation_input(input), CONFIRMATION_RECOVERY)
 }
 

package/scripts/init/init-actions.ts

@@ -106,7 +106,7 @@ function build_basic_settings_action(): FileAction {
 }
 
 function build_basic_vscode_actions(shape: ProjectShape): ReadonlyArray<FileAction> {
-	const recommendations = shape.has_web
+	const recommendations = shape.should_use_prettier
 		? [...BASIC_EXTENSIONS, PRETTIER_EXTENSION]
 		: BASIC_EXTENSIONS
 	const actions: Array<FileAction> = [
@@ -117,7 +117,7 @@ function build_basic_vscode_actions(shape: ProjectShape): ReadonlyArray<FileActi
 		),
 	]
 
-	if (shape.has_web) actions.push(build_basic_settings_action())
+	if (shape.should_use_prettier) actions.push(build_basic_settings_action())
 
 	return actions
 }
@@ -210,7 +210,7 @@ function build_basic_actions(shape: ProjectShape): ReadonlyArray<FileAction> {
 	if (shape.has_git) actions.push(build_gitignore_action())
 	if (shape.has_typescript) actions.push(build_basic_tsconfig_action())
 
-	if (shape.has_web) {
+	if (shape.should_use_prettier) {
 		actions.push({
 			dest: BASIC_PRETTIER_CONFIG,
 			create: () =>

package/scripts/init/init-ai-copy.ts

@@ -348,7 +348,7 @@ function should_copy_github_file(filename: string, shape?: ProjectShape): boolea
 function should_copy_basic_file(filename: string, shape?: ProjectShape): boolean {
 	if (filename !== PRETTIER_IGNORE || shape?.profile !== 'basic') return true
 
-	return shape.has_web
+	return shape.should_use_prettier
 }
 
 function should_copy_ai_file(filename: string, shape?: ProjectShape): boolean {

package/scripts/init/init-basic.ts

@@ -45,7 +45,7 @@ function merge_basic_manifest(
 	const with_kit = init_logic.merge_development_dependencies(with_script, {
 		[KIT_PACKAGE_NAME]: versions.kit,
 	})
-	const with_prettier = shape.has_web
+	const with_prettier = shape.should_use_prettier
 		? init_logic.merge_development_dependencies(with_kit, { prettier: versions.prettier })
 		: with_kit
 

package/scripts/init/init-bootstrap.ts

@@ -82,13 +82,17 @@ function ensure_project_manifest(project_root: string): void {
 	if (!existsSync(manifest_path)) writeFileSync(manifest_path, init_basic.initial_manifest())
 }
 
+function is_handed_off(): boolean {
+	return process.env[HANDOFF_ENV] !== undefined
+}
+
 // Returns the failure to report, or undefined once the project-installed kit finished the setup.
 function hand_off(
 	package_directory: string,
 	project_root: string,
 	args: ReadonlyArray<string>,
 ): string | undefined {
-	if (process.env[HANDOFF_ENV] !== undefined) return REPEATED_HANDOFF
+	if (is_handed_off()) return REPEATED_HANDOFF
 	console.info('\n🚀 Installing @joshuafolkken/kit into the project, then running its josh init')
 	const template = readFileSync(path.join(package_directory, KIT_BUILDS_TEMPLATE), 'utf8')
 	const install = kit_install_step(has_kit_dependency(project_root), template)
@@ -100,5 +104,5 @@ function hand_off(
 	return undefined
 }
 
-const init_bootstrap = { is_project_kit, kit_build_flags, hand_off }
+const init_bootstrap = { HANDOFF_ENV, is_project_kit, kit_build_flags, hand_off, is_handed_off }
 export { init_bootstrap }