@joshuafolkken/kit 1.1128.0 → 1.1136.0

package/scripts/delegation/delegation-policy.ts

@@ -32,6 +32,13 @@ interface DelegatableStep {
 // wait per turn — and below the threshold that round trip costs more than carrying the text.
 const INVESTIGATION_FILE_THRESHOLD = 3
 
+// The same boundary for searches, counted in turns (joshuafolkken/kit#3139). A `grep` carries no file
+// text, so it never reached the file count — yet across 100 lane transcripts on 2026-10-04, 424 turns
+// were searches alone and 160 of them came third or later since the last edit or delegation, each
+// re-reading the whole main-line context. Three keeps the first two searches, which locate an edit
+// target, in the main line and sends the continuing sweep to a unit.
+const INVESTIGATION_SEARCH_TURN_THRESHOLD = 3
+
 // The enumeration. Short on purpose: every entry had to name a verifier, and most candidates could
 // not (below).
 const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
@@ -88,7 +95,7 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 		// verifiers differ, so widening `survey` would put both in one field and lose the boundary below.
 		// **No ordinal.** `${N}rd` would print `1rd` for any other threshold, past a test that only looks
 		// for the numeral, so the count is phrased as a plain "N or more".
-		does: `read the Issue's subject to find out how it currently works — once ${String(INVESTIGATION_FILE_THRESHOLD)} or more files the run will not edit have to be read — and return the conclusion plus the \`file:line\` citations that support it, never the file text, which would put the cost back where it was. A throwaway probe script is written, run and deleted inside the unit, which returns its output alone`,
+		does: `read the Issue's subject to find out how it currently works — once ${String(INVESTIGATION_FILE_THRESHOLD)} or more files the run will not edit have to be read, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} or more search turns run without an edit — and return the conclusion plus the \`file:line\` citations that support it, never the file text, which would put the cost back where it was. A throwaway probe script is written, run and deleted inside the unit, which returns its output alone`,
 		verifier:
 			'the parent opens the cited lines; a conclusion those lines do not support fails there, and reading a handful of cited regions costs far less than redoing the reading. The unit reports what the code does and never what to change — deciding that is `diagnosis`, which stays kept, so a unit returning a root cause would be delegating the rejected row under this name',
 	},
@@ -176,6 +183,7 @@ function reason_for(name: string): string {
 const delegation_policy = {
 	DELEGATE_VERDICT,
 	INVESTIGATION_FILE_THRESHOLD,
+	INVESTIGATION_SEARCH_TURN_THRESHOLD,
 	KEEP_VERDICT,
 	DELEGATABLE_STEPS,
 	REJECTED_STEPS,

package/scripts/delegation/investigation-guard.ts

@@ -72,7 +72,7 @@ function should_notify(
 // (joshuafolkken/kit#2138, joshuafolkken/kit#2382). A dispatched lane child ends its turn on a denial, so
 // the same guidance is carried without a `permissionDecision`: the read proceeds and the child is nudged
 // to delegate rather than killed. It carries no ⛔, so a person watching reads it as advice.
-const NOTICE = `💡 investigation: files read and not edited since the last delegated unit reached the threshold, so the reading from here should go to a unit of its own. This is a notice, not a refusal — the read proceeds, because a dispatched lane child ends its turn on a denial. Ask \`pnpm josh delegate investigation\`, then brief a unit with what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file. This recurs on the next accumulation.`
+const NOTICE = `💡 investigation: files read and not edited, or search turns, since the last delegated unit reached the threshold, so the reading from here should go to a unit of its own. This is a notice, not a refusal — the read proceeds, because a dispatched lane child ends its turn on a denial. Ask \`pnpm josh delegate investigation\`, then dispatch the \`${investigation_reads.INVESTIGATOR_AGENT}\` agent (\`kit:${investigation_reads.INVESTIGATOR_AGENT}\` in a consumer) with a brief of what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file. This recurs on the next accumulation.`
 
 // The notice as it reaches the model: the base guidance with the concrete unedited reads named (kit#2276,
 // kit#2382), so a lane child is shown *which* reads to send to a unit rather than only told to delegate —

package/scripts/delegation/investigation-reads.ts

@@ -55,10 +55,23 @@ const CONTENT_READ_LABELS: ReadonlySet<string> = new Set(
 	CONTENT_READ_COMMANDS.map((command) => time_shell.bash_label(command)),
 )
 
+// **The searches carry no file text, so they are counted in turns rather than files**
+// (joshuafolkken/kit#3139). The file count above never saw a `grep`, yet searches were the commonest
+// exploration turn a lane took — 457 of them in one day, each re-reading the main line's whole context.
+// What a search costs is the turn, so a turn is the unit: parallel searches in one turn count once.
+const SEARCH_COMMANDS: ReadonlyArray<string> = ['fd', 'find', 'grep', 'rg']
+const SEARCH_LABELS: ReadonlySet<string> = new Set(
+	SEARCH_COMMANDS.map((command) => time_shell.bash_label(command)),
+)
+
+// The unit the refusal sends the reading to (joshuafolkken/kit#3139): `.claude/agents/investigator.md`,
+// the parent's model at a lowered effort. A consumer receives it through the plugin as `kit:investigator`.
+const INVESTIGATOR_AGENT = 'investigator'
+
 // What the refusal tells the model. It has to name the count, the command and the return shape,
 // because the deny reason is the only text that reaches the model — a run that is refused and told
 // nothing reads it as a broken tool.
-const REASON = `⛔ investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited since the last delegated unit, so the reading from here goes to a unit of its own. Ask \`pnpm josh delegate investigation\`, then brief a unit with what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file — an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files — a backgrounded call's output, a persisted tool result, this session's scratchpad — are never counted, so they are not what took the count here. The rule is \`.claude/skills/workflow-commands/SKILL.md\` → §2b, "The pre-implementation reading".`
+const REASON = `⛔ investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit, so the reading from here goes to a unit of its own (a successful write also starts the search count over). Ask \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with a brief of what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file — an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files — a backgrounded call's output, a persisted tool result, this session's scratchpad — never count toward the files, so they are not what took the file count here; every read-only search turn counts, whatever it names. The rule is \`.claude/skills/workflow-commands/SKILL.md\` → §2b, "The pre-implementation reading".`
 
 interface ReadTally {
 	// The files read and not since edited, resolved so the two ways a target reaches here compare.
@@ -74,6 +87,10 @@ interface ReadTally {
 	// The first instant the window covers. A refusal recorded before it cannot be checked against a
 	// delegation any more, because the delegation that would re-arm it has scrolled out.
 	window_start_ms: number
+	// The search turns since the last delegation or successful write, and how many of them came after
+	// the instant asked about — the search-side `pending` / `pending_since` (joshuafolkken/kit#3139).
+	searches: number
+	searches_since: number
 	// The files this run has successfully edited within the window, resolved (joshuafolkken/kit#1840).
 	// A re-read of one of them is a read of a file the run edited, which §2b keeps in the main line — so
 	// it is excluded from the count and from a call's projected growth rather than counted as fresh
@@ -279,18 +296,65 @@ function add_all(
 // the edit's own span, so a read issued *after* the edit was added and stayed. `sed -i`, `MultiEdit`
 // and `NotebookEdit` need no special case any more — each is a write, so its target is in `edited` and
 // never enters the read count.
-function apply_span(pending: Map<string, number>, span: Span, edited: ReadonlySet<string>): void {
+interface Accumulation {
+	// Read files, keyed by resolved path, valued by the instant each entered.
+	pending: Map<string, number>
+	// Search turns, keyed by message id so a turn's parallel searches count once, valued the same way.
+	searches: Map<string, number>
+}
+
+function is_read_only_search(span: Span): boolean {
+	return SEARCH_LABELS.has(span.label) && span.is_bundleable && !span.may_write
+}
+
+// **A span with no message id belongs to no known turn, so it is a turn of its own** — the reading every
+// other turn counter gives `NO_MESSAGE_ID` (`time-round-trips.ts`, `time-bundles.ts`). Keyed by the
+// id, every untagged search would collapse into one entry and the count would never reach its threshold.
+function search_turn_key(searches: ReadonlyMap<string, number>, span: Span): string {
+	if (span.message_id !== time_spans.NO_MESSAGE_ID) return span.message_id
+
+	return `${time_spans.NO_MESSAGE_ID}#${String(searches.size)}`
+}
+
+// **A successful write ends the streak.** The measurement behind the threshold counted searches since
+// the last edit or delegation: a run that has started writing is implementing, and the searches that
+// follow locate the next edit rather than continue an investigation.
+//
+// **Every read-only search counts, whatever it names** (joshuafolkken/kit#3139). The file count can
+// exempt the run's own instructions because a read names each file it reads; a search does not — the
+// targets drop a bare directory, so `grep -rn foo CLAUDE.md scripts` looked like a search of
+// `CLAUDE.md` alone and an exemption let the whole sweep through. `is_bundleable` without `may_write`
+// is the read-only test `is_search_call` asks at the call, so the transcript never counts a search the
+// guard could not have refused.
+function apply_search(searches: Map<string, number>, span: Span): void {
+	if (span.is_writing) {
+		searches.clear()
+
+		return
+	}
+
+	const turn = search_turn_key(searches, span)
+
+	if (is_read_only_search(span) && !searches.has(turn)) searches.set(turn, span.ended_ms)
+}
+
+function apply_span(accumulation: Accumulation, span: Span, edited: ReadonlySet<string>): void {
 	if (DELEGATION_TOOLS.has(span.label)) {
-		pending.clear()
+		accumulation.pending.clear()
+		accumulation.searches.clear()
 
 		return
 	}
 
-	if (!is_content_read(span.label) || is_failed_outcome(span)) return
+	if (is_failed_outcome(span)) return
+
+	apply_search(accumulation.searches, span)
+
+	if (!is_content_read(span.label)) return
 
 	const fresh = subject_targets(span.targets).filter((target) => !edited.has(target))
 
-	add_all(pending, fresh, span.ended_ms)
+	add_all(accumulation.pending, fresh, span.ended_ms)
 }
 
 function last_delegation_ms(spans: ReadonlyArray<Span>): number {
@@ -307,15 +371,17 @@ function pending_after(pending: ReadonlyMap<string, number>, since_ms: number):
 function tally_of(text: string, since_ms: number = hook_decision.NEVER_MS): ReadTally {
 	const { spans, started_ms } = time_spans.parse_timeline(text)
 	const edited = edited_files(spans)
-	const pending = new Map<string, number>()
+	const accumulation: Accumulation = { pending: new Map(), searches: new Map() }
 
-	for (const span of spans) apply_span(pending, span, edited)
+	for (const span of spans) apply_span(accumulation, span, edited)
 
 	return {
-		pending: [...pending.keys()],
-		pending_since: pending_after(pending, since_ms),
+		pending: [...accumulation.pending.keys()],
+		pending_since: pending_after(accumulation.pending, since_ms),
 		reset_ms: last_delegation_ms(spans),
 		window_start_ms: started_ms,
+		searches: accumulation.searches.size,
+		searches_since: pending_after(accumulation.searches, since_ms),
 		edited,
 	}
 }
@@ -347,6 +413,11 @@ function is_at_threshold(pending_count: number): boolean {
 	return pending_count + 1 >= delegation_policy.INVESTIGATION_FILE_THRESHOLD
 }
 
+// The search turn that takes the count up to its threshold is the boundary, as above.
+function is_at_search_threshold(search_count: number): boolean {
+	return search_count + 1 >= delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD
+}
+
 // **One refusal per accumulation, re-armed by a delegation and by nothing else.** A run that reads on
 // regardless is not refused again, so a false positive — three files the run was about to edit — costs
 // one round trip rather than wedging the run. And a run that *does* delegate is refused again as soon
@@ -386,7 +457,7 @@ function is_rearmed(tally: ReadTally, refused_at_ms: number): boolean {
 		return true
 	}
 
-	return is_at_threshold(tally.pending_since)
+	return is_at_threshold(tally.pending_since) || is_at_search_threshold(tally.searches_since)
 }
 
 // A transcript under a session's `subagents/` directory is a delegated unit's. The segment is
@@ -403,10 +474,19 @@ function is_unit_run(run: GuardRun | undefined): boolean {
 	return run !== undefined && is_unit_transcript(run.transcript)
 }
 
-function is_refusable_command(call: GuardedCall): boolean {
+function is_read_only_command(call: GuardedCall, labels: ReadonlySet<string>): boolean {
+	if (call.name !== cost_blocks.BASH_TOOL) return false
+
 	const label = time_shell.bash_label(time_shell.bash_command(call.input))
 
-	return CONTENT_READ_LABELS.has(label) && time_batch_guard.is_read_only_call(call)
+	return labels.has(label) && time_batch_guard.is_read_only_call(call)
+}
+
+// **A search is refusable without a subject target**, unlike a read: `grep -rn foo scripts` names a
+// bare directory, which `call_facts` deliberately does not take as a target, and such a sweep is exactly
+// the search this count exists for.
+function is_search_call(call: GuardedCall): boolean {
+	return is_read_only_command(call, SEARCH_LABELS)
 }
 
 // **A `Read` is always safe to refuse; a `Bash` line is refused only where it writes nothing.** This
@@ -427,10 +507,20 @@ function is_refusable_command(call: GuardedCall): boolean {
 // rule being enforced — and a call whose targets could not be read at all, which cannot move the count
 // and so has nothing to be refused for.
 function is_refusable_call(call: GuardedCall): boolean {
+	if (is_search_call(call)) return true
 	if (call_targets(call).length === 0) return false
 	if (READ_TOOLS.has(call.name)) return true
 
-	return call.name === cost_blocks.BASH_TOOL && is_refusable_command(call)
+	return is_read_only_command(call, CONTENT_READ_LABELS)
+}
+
+// A search call grows the search count by its own turn; a read grows the file count only by a file the
+// count does not already hold.
+function is_growing_past_threshold(tally: ReadTally, call: GuardedCall): boolean {
+	if (is_search_call(call)) return is_at_search_threshold(tally.searches)
+	if (!is_at_threshold(tally.pending.length)) return false
+
+	return projected_count(tally.pending, call, tally.edited) > tally.pending.length
 }
 
 function should_block(
@@ -446,15 +536,11 @@ function should_block(
 
 	const tally = tally_of(text, refused_at_ms)
 
-	if (!is_at_threshold(tally.pending.length)) return false
-
-	return (
-		projected_count(tally.pending, call, tally.edited) > tally.pending.length &&
-		is_rearmed(tally, refused_at_ms)
-	)
+	return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms)
 }
 
 const investigation_reads = {
+	INVESTIGATOR_AGENT,
 	READ_TOOLS,
 	REASON,
 	is_at_threshold,

package/scripts/document/capped-print.ts

@@ -0,0 +1,74 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
+import { review_diff_parts } from '#scripts/review/review-diff-parts'
+import { bash_output_cap_reader } from './bash-output-cap'
+
+// Prints a command's output whole when it fits under the Bash output cap, and as part files when it
+// does not (joshuafolkken/kit#3143). Past `BASH_MAX_OUTPUT_LENGTH` Claude Code saves the output and
+// hands back a 2 KB preview, and the run spends a turn reading the saved file — 224 overflows and 132
+// re-reads over one day's sessions, `doc:section` and `issue:read` the two most frequent `josh` sources.
+//
+// **The cut is #2963's, not a second one.** The parts come from `review_diff_parts.part_texts`, so each
+// file — header included — fits under the cap and the bodies concatenate back to exactly the output.
+// A reader opens them all with the Read tool in one turn, which is the turn the preview used to cost.
+//
+// **A fresh directory per call**, unlike the review's per-checkout one: a run fetches several sections
+// in one turn, and a shared directory replaced on every call would delete one call's parts while
+// another call's listing still names them.
+
+const DIRECTORY_PREFIX = 'josh-capped-print-'
+const FILE_MODE = 0o600
+const PART_SUFFIX = '.md'
+const LINE_BREAK = '\n'
+// What else shares the Bash result with this output: the launcher line, a script banner, a few
+// stderr lines. Measured at about 80 characters for `pnpm josh doc:section` in kit, so 512 holds the
+// longest heading or issue list with room for a consumer's banner.
+const HEADROOM_CHARS = 512
+
+function write_parts(label: string, text: string, cap: number): Array<string> {
+	const directory = mkdtempSync(path.join(PLATFORM_TEMP_ROOT, DIRECTORY_PREFIX))
+
+	return review_diff_parts.part_texts(label, text, cap).map((part, index) => {
+		const file = path.join(directory, `part-${String(index + 1)}${PART_SUFFIX}`)
+
+		writeFileSync(file, part, { flag: 'wx', mode: FILE_MODE })
+
+		return file
+	})
+}
+
+function part_count(count: number): string {
+	return `written as ${String(count)} part file${count === 1 ? '' : 's'} under it`
+}
+
+function listing(text: string, cap: number, files: ReadonlyArray<string>): string {
+	const figures = `${text.length.toLocaleString('en-US')} > ${cap.toLocaleString('en-US')} characters`
+	const lead = `Over the Bash cap (${figures}) — ${part_count(files.length)}, together exactly the output. Read every part with the Read tool, in one turn, not cat:`
+
+	return [lead, ...files.map((file) => `  ${file}`)].join(LINE_BREAK)
+}
+
+// **The budget is the cap less a headroom, not the cap.** The Bash result carries more than this
+// output — `pnpm josh`'s own launcher line, a consumer's script banner, the stderr lines naming a
+// number that did not resolve — so a text measured against the bare cap would overflow by exactly
+// those lines, and cost the re-read this module exists to remove.
+function output_budget(root: string): number {
+	return Math.max(1, bash_output_cap_reader.bash_output_cap(root) - HEADROOM_CHARS)
+}
+
+function capped_print(text: string, label: string, root: string = process.cwd()): void {
+	const budget = output_budget(root)
+
+	if (text.length < budget) {
+		console.info(text)
+
+		return
+	}
+
+	console.info(listing(text, budget, write_parts(label, text, budget)))
+}
+
+const capped_output = { HEADROOM_CHARS, capped_print }
+
+export { capped_output }

package/scripts/document/document-section-cli.ts

@@ -2,6 +2,7 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { capped_output } from './capped-print'
 import { document_section } from './document-section'
 import { entry_read_set } from './entry-read-set'
 
@@ -56,12 +57,12 @@ function report_missing(markdown: string, heading: string): number {
 	return FAILURE_EXIT_CODE
 }
 
-function print_section(markdown: string, heading: string): number {
+function print_section(markdown: string, heading: string, root: string): number {
 	const found = document_section.section(markdown, heading)
 
 	if (found === undefined) return report_missing(markdown, heading)
 
-	console.info(found.text)
+	capped_output.capped_print(found.text, heading, root)
 
 	return 0
 }
@@ -87,7 +88,7 @@ function run(argv: ReadonlyArray<string>, root: string = process.cwd()): number
 
 	const markdown = read_named(name, root)
 
-	return markdown === undefined ? FAILURE_EXIT_CODE : print_section(markdown, heading)
+	return markdown === undefined ? FAILURE_EXIT_CODE : print_section(markdown, heading, root)
 }
 
 function main(argv: ReadonlyArray<string>): void {

package/scripts/gate/scoped-green.ts

@@ -2,6 +2,7 @@ import { file_map_stamp, type FileMapStampAccess } from '#scripts/josh/file-map-
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { review_brief } from '#scripts/review/review-brief'
 import { review_stamps } from '#scripts/review/review-stamps'
+import { test_unit_guard } from '#scripts/test/test-unit-guard'
 import { gate_tree, type GateTree } from './gate-tree'
 
 // Whether the two scoped checks have been green on *this exact tree* by the time the review is
@@ -60,26 +61,36 @@ interface ScopedCheck {
 
 // The record paths, overridable so a test can plant one without overwriting the record a real run in
 // this checkout relies on — the same reason `gate_skip.reusable_green_gate` takes a `source`.
+// `is_unit_skipped` is overridable for the same reason, so a suite running in a checkout with vitest
+// can stand in for a project without one.
 interface ScopedSources {
 	lint?: string
 	test?: string
+	is_unit_skipped?: boolean
 }
 
+// **`test:related` is required only where it can ever answer** (joshuafolkken/kit#3136). In a project
+// whose unit guard skips — vitest absent, or a basic project with no test file — `test:related` runs
+// nothing and so writes no record, and requiring one refused the gate forever with no way through.
+// The guard's own decision is asked rather than re-derived, so the writer and this reader agree; a
+// project with a unit suite still needs the record, and a run that executed nothing still writes none.
 function checks_of(sources: ScopedSources): ReadonlyArray<ScopedCheck> {
-	return [
-		{
-			script: LINT_SCRIPT,
-			command: LINT_COMMAND,
-			stamp: review_stamps.lint_related_stamp,
-			source: sources.lint,
-		},
-		{
-			script: TEST_SCRIPT,
-			command: TEST_COMMAND,
-			stamp: review_stamps.test_related_stamp,
-			source: sources.test,
-		},
-	]
+	const lint = {
+		script: LINT_SCRIPT,
+		command: LINT_COMMAND,
+		stamp: review_stamps.lint_related_stamp,
+		source: sources.lint,
+	}
+	const test = {
+		script: TEST_SCRIPT,
+		command: TEST_COMMAND,
+		stamp: review_stamps.test_related_stamp,
+		source: sources.test,
+	}
+
+	return (sources.is_unit_skipped ?? test_unit_guard.is_skipping(process.cwd()))
+		? [lint]
+		: [lint, test]
 }
 
 // **An unreadable record reads as an absent one, and that is the safe direction.** `read` swallows a

package/scripts/init/claude-kit-only-settings.ts

@@ -0,0 +1,29 @@
+import { patch_json_key } from '#scripts/config-merge/patch-json-key'
+import { claude_plugin_config } from './claude-plugin-config'
+
+// Keys kit's own `.claude/settings.json` sets for its sessions but never ships. `enableArtifact:
+// false` keeps the Artifact tool's ~12k tokens out of every call of a kit run
+// (joshuafolkken/kit#3140), but Claude Code lets any layer that sets it to `false` win, so a
+// consumer given it could not turn the tool back on from `.claude/settings.local.json`.
+const KIT_ONLY_SETTING_KEYS: ReadonlyArray<string> = ['enableArtifact']
+
+function strip_kit_only_settings(content: string): string {
+	let stripped = content
+	for (const key of KIT_ONLY_SETTING_KEYS) stripped = patch_json_key.remove_json_key(stripped, key)
+
+	return stripped
+}
+
+function apply_kit_only_strip_for_destination(destination_path: string, content: string): string {
+	return destination_path.endsWith(claude_plugin_config.CLAUDE_SETTINGS_DESTINATION)
+		? strip_kit_only_settings(content)
+		: content
+}
+
+const claude_kit_only_settings = {
+	KIT_ONLY_SETTING_KEYS,
+	strip_kit_only_settings,
+	apply_kit_only_strip_for_destination,
+}
+
+export { claude_kit_only_settings }

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

@@ -1,6 +1,7 @@
 import { managed_marker_logic } from '#scripts/managed-marker/managed-marker-logic'
 import { workflow_pin_logic } from '#scripts/sync/workflow-pin-logic'
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
+import { claude_kit_only_settings } from './claude-kit-only-settings'
 import { claude_plugin_config } from './claude-plugin-config'
 import { hook_command_rewrite } from './hook-command-rewrite'
 import { init_logic } from './init-logic'
@@ -19,7 +20,8 @@ import { init_logic } from './init-logic'
  * workflow-pin-logic.ts for why the template refs are not authoritative, and
  * managed-marker-logic.ts for why the stamp is on the file rather than in a list.
  *
- * The consumer's `.claude/settings.json` gets two further passes. The kit plugin's marketplace and
+ * The consumer's `.claude/settings.json` gets three further passes. The keys kit sets only for its
+ * own sessions are removed (joshuafolkken/kit#3140, see claude-kit-only-settings.ts). The kit plugin's marketplace and
  * `enabledPlugins` declaration is injected, because the skills that used to be copied now ship as the
  * `kit` plugin and load from that declaration (joshuafolkken/kit#1879). And its hook commands are
  * rewritten from `pnpm josh` to the published bundle invoked directly with node
@@ -36,10 +38,14 @@ function transform_copied_content(destination_path: string, content: string): st
 		with_pins,
 		KIT_PACKAGE_NAME,
 	)
-	const with_plugin = claude_plugin_config.apply_plugin_config_for_destination(
+	const with_kit_only_stripped = claude_kit_only_settings.apply_kit_only_strip_for_destination(
 		destination_path,
 		with_marker,
 	)
+	const with_plugin = claude_plugin_config.apply_plugin_config_for_destination(
+		destination_path,
+		with_kit_only_stripped,
+	)
 
 	return hook_command_rewrite.apply_hook_command_rewrite_for_destination(
 		destination_path,

package/scripts/init/initial-commit.ts

@@ -0,0 +1,24 @@
+import { start_exec } from './start-exec'
+
+// The first commit of a new repository, shared by `josh start` and `josh dogfood:commit` so neither
+// keeps a copy of how it is made.
+
+const DEFAULT_BRANCH = 'main'
+
+function create_repository(root: string): void {
+	start_exec.run('git', ['init', `--initial-branch=${DEFAULT_BRANCH}`], root)
+}
+
+function commit_all(root: string): void {
+	start_exec.run('git', ['add', '--all'], root)
+	// The first commit of a new repository has no branch to come from, so the hook that keeps commits
+	// off main — installed by the initialize step in a full project — would refuse the only commit
+	// that has to land there.
+	start_exec.run('git', ['commit', '--no-verify', '--message', 'Initial commit'], root)
+	// A repository created by an older `git init` may name its unborn branch `master`.
+	start_exec.run('git', ['branch', '--move', '--force', DEFAULT_BRANCH], root)
+}
+
+const initial_commit = { create_repository, commit_all }
+
+export { initial_commit }

package/scripts/init/start-exec.ts

@@ -1,10 +1,21 @@
 import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { git_location_environment } from '#scripts/git/git-location-environment'
 import { execaSync } from 'execa'
 
 // The three spawn shapes every `josh start` step uses, shared by `start-steps.ts`, the setup pull
 // request step and the `josh init` hint so none of them keeps a copy of its own.
+//
+// The three git-driving shapes below act on `root`, so `cwd` has to mean it: an inherited `GIT_DIR` and friends beat `cwd`
+// and would carry a `git init` or commit into whichever repository a calling hook was firing in
+// (joshuafolkken/kit#3151).
+function root_environment(): Record<string, string | undefined> {
+	return git_location_environment.location_free_environment()
+}
+
 function succeeds(command: string, args: ReadonlyArray<string>, root: string): boolean {
-	return execaSync(command, args, { cwd: root, reject: false }).exitCode === 0
+	return (
+		execaSync(command, args, { cwd: root, env: root_environment(), reject: false }).exitCode === 0
+	)
 }
 
 function read_output(
@@ -12,7 +23,7 @@ function read_output(
 	args: ReadonlyArray<string>,
 	root: string,
 ): string | undefined {
-	const result = execaSync(command, args, { cwd: root, reject: false })
+	const result = execaSync(command, args, { cwd: root, env: root_environment(), reject: false })
 
 	return result.exitCode === 0 ? result.stdout.trim() : undefined
 }
@@ -20,7 +31,9 @@ function read_output(
 // Every step spawned here dials GitHub directly, past a scanner's loopback proxy, the same as every
 // other `gh` spawn under scripts/ (joshuafolkken/kit#2436); a local `git` step is unaffected by it.
 function run(command: string, args: ReadonlyArray<string>, root: string): void {
-	execaSync(command, args, { ...git_gh_exec.direct_environment(), cwd: root, stdio: 'inherit' })
+	const environment = { ...root_environment(), ...git_gh_exec.direct_environment().env }
+
+	execaSync(command, args, { env: environment, cwd: root, stdio: 'inherit' })
 }
 
 // A caller's own initialize command stands in for the in-process `josh init`, so it keeps the

package/scripts/init/start-steps.ts

@@ -6,6 +6,7 @@ import { self_sync_guard } from '#scripts/self-sync-guard/self-sync-guard-logic'
 import { parseCommandString } from 'execa'
 import { main as init_main } from './init'
 import { PACKAGE_DIR } from './init-paths'
+import { initial_commit } from './initial-commit'
 import { kit_setup_state } from './kit-setup-state'
 import type { ProjectProfile, ProjectShape } from './project-profile'
 import { start_exec } from './start-exec'
@@ -23,7 +24,6 @@ interface RunContext extends StepContext {
 	baseline: ReadonlyArray<string> | undefined
 }
 
-const DEFAULT_BRANCH = 'main'
 const GH_INSTALL_HINT =
 	'GitHub CLI (gh) is not installed. Install it from https://cli.github.com/, run gh auth login, then run josh start again. Nothing was changed.'
 const GH_AUTH_HINT =
@@ -70,7 +70,7 @@ function self_run_refusal(root: string): string | undefined {
 }
 
 function create_git_repository(context: StepContext): void {
-	run('git', ['init', `--initial-branch=${DEFAULT_BRANCH}`], context.root)
+	initial_commit.create_repository(context.root)
 }
 
 // The same setup `josh init` runs, called rather than copied, with the profile the user confirmed.
@@ -90,13 +90,7 @@ function initialize(context: StepContext): void {
 }
 
 function commit_all(context: StepContext): void {
-	run('git', ['add', '--all'], context.root)
-	// The first commit of a new repository has no branch to come from, so the hook that keeps commits
-	// off main — installed by the initialize step in a full project — would refuse the only commit
-	// that has to land there.
-	run('git', ['commit', '--no-verify', '--message', 'Initial commit'], context.root)
-	// A repository created by an older `git init` may name its unborn branch `master`.
-	run('git', ['branch', '--move', '--force', DEFAULT_BRANCH], context.root)
+	initial_commit.commit_all(context.root)
 }
 
 function create_github_repository(context: StepContext): void {
@@ -119,13 +113,15 @@ async function open_setup_pull_request(context: RunContext): Promise<void> {
 	await start_setup_pr.open(context.root, context.baseline)
 }
 
-// What was already changed before a caller's initialize command ran, read only when the setup pull
-// request will need to tell that command's files from the user's own (#2872).
+// What was already changed before the setup ran, read whenever a setup pull request will follow, so
+// it can tell the setup's files from the user's own (#2872). Kit's own `josh init` needs it as much as
+// a caller's command: its `josh format` rewrites the project's own sources, which kit cannot name, and
+// leaving them out failed the pull request's Prettier check (joshuafolkken/kit#3136).
 function baseline_of(
 	steps: ReadonlyArray<StartStep>,
 	context: StepContext,
 ): ReadonlyArray<string> | undefined {
-	if (context.init_command === undefined || !steps.includes('setup_pr')) return undefined
+	if (!steps.includes('setup_pr')) return undefined
 
 	return start_setup_pr.changed_paths(context.root)
 }

package/scripts/issue/issue-read-cli.ts

@@ -129,6 +129,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	issue_report_failures.print_blocks(
 		reports.flatMap((report) => issue_blocks(report)),
 		BLOCK_SEPARATOR,
+		`issue:read ${issue_numbers.join(' ')}`,
 	)
 
 	return issue_report_failures.report_failures(reports, FAILURE_TERMS)

package/scripts/issue/issue-report-failures.ts

@@ -1,3 +1,5 @@
+import { capped_output } from '#scripts/document/capped-print'
+
 // The failure report `issue:read` and `issue:state` share (joshuafolkken/kit#3046). Both read a batch
 // of numbers, print a block for each one that answered, and name every one that did not; only the
 // result kind that counts as an answer and what a gap must not be mistaken for differ between them.
@@ -22,10 +24,12 @@ interface FailureTerms<K extends string> {
 	misreading: string
 }
 
-function print_blocks(blocks: ReadonlyArray<string>, separator: string): void {
+// Under the Bash output cap, or as part files past it — a batch of long threads is the shape that
+// overflowed (joshuafolkken/kit#3143).
+function print_blocks(blocks: ReadonlyArray<string>, separator: string, label: string): void {
 	if (blocks.length === 0) return
 
-	console.info(blocks.join(separator))
+	capped_output.capped_print(blocks.join(separator), label)
 }
 
 // A number that resolves to nothing is an answer — a typo, or another repository's number quoted in