@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/hooks/format-edited-file.ts

@@ -360,6 +360,19 @@ async function collect_unfixed(
 	return unfixed
 }
 
+// The edited file as the daemon read it, or nothing when no eslint command linted it — a `.json`
+// module prettier alone formats is still in the type program, and a refreshed record would hide its
+// old copy there (joshuafolkken/kit#4867).
+function linted_path(
+	plan: ReadonlyArray<FormatCommand>,
+	file_path: string,
+	project_root: string,
+): string | undefined {
+	if (plan.every((command) => command.bin !== ESLINT_BIN)) return undefined
+
+	return relative_to_root(project_root, file_path)
+}
+
 async function format_edited_file(
 	raw_payload: string,
 	runner: CommandRunner,
@@ -376,7 +389,11 @@ async function format_edited_file(
 	const daemon_before = eslint_daemon.read_record(project_root)
 	const unfixed = await collect_unfixed(plan, runner, project_root)
 
-	eslint_daemon.remember_started(project_root, daemon_before)
+	eslint_daemon.remember_after_edit(
+		project_root,
+		daemon_before,
+		linted_path(plan, file_path, project_root),
+	)
 
 	return format_diagnostics(unfixed === '' ? undefined : unfixed)
 }
@@ -444,15 +461,18 @@ function report_no_payload(): void {
 // its content before the formatters ran against its content after — so it too is known only once they
 // have. The rewrite, lint and spell blocks are composed together first, then
 // joined to the density line — one envelope, since a `PostToolUse` hook's stdout carries only one.
+// The spell check runs beside the formatters rather than after them, on the text as the edit left it:
+// it was the hook's largest step (joshuafolkken/kit#4596), and a formatter rewrites layout, not words.
 // A hook killed at its 15s timeout is the one case this loses the density
 // line to — a run already gone pathologically wrong, per HOOK_PROCESS_TIMEOUT_MS.
 async function run_hook(payload: string): Promise<void> {
 	const notice = time_density_hook.density_notice(payload)
 	const file_path = parse_edited_path(payload)
 	const before = rewrite_notice.read_text(file_path)
+	const pending_spelling = edited_cspell.spelling_diagnostics(file_path, process.cwd(), before)
 	const lint = await format_edited_payload(payload, process.cwd())
 	const rewrite = rewrite_notice.build(before, rewrite_notice.read_text(file_path))
-	const spelling = await edited_cspell.spelling_diagnostics(file_path, process.cwd())
+	const spelling = await pending_spelling
 	const parts = compose_context(rewrite, compose_context(lint, spelling))
 	const context = compose_context(notice, parts)
 

package/scripts/hooks/lane-plan-guard.ts

@@ -0,0 +1,50 @@
+import { lane_child_marker, type MarkerSource } from '#scripts/lane/lane-child-marker'
+import { lane_plan } from '#scripts/lane/lane-plan'
+import { step_zero_notice } from './step-zero-notice'
+
+// A dispatched lane child's first implementation edit is refused until `josh lane:plan` has recorded
+// the files its work summary changes and cleared them (joshuafolkken/kit#4864). The record is what holds a later lane
+// back from those files, so it has to exist before the code does; a document asking for it would be
+// read after the edit it governs.
+//
+// **A dispatched lane child only**, the trust condition `lane-phase.ts` applies: a person's session, or
+// one carrying a mark leaked from a parent, runs no lanes beside it to wait on.
+
+const COMMAND_DOC = '`docs/josh-commands-run.md` → "`josh lane:plan`"'
+const OUTCOMES =
+	'on `yield` end the session with no edit (its lane is given back); on `wait` run it again'
+
+function reason_text(issue: string): string {
+	const command = `\`pnpm josh lane:plan ${issue} <path>...\``
+
+	return `⛔ lane plan: run ${command} naming every file the work summary changes before the first implementation edit — ${OUTCOMES} (${COMMAND_DOC}).`
+}
+
+// The issue of the dispatched lane child making this runtime edit, or `undefined` for any other call.
+function lane_child_edit(
+	raw_payload: string,
+	directory: string,
+	source: MarkerSource,
+): string | undefined {
+	if (!lane_child_marker.is_child_of(directory, source)) return undefined
+
+	return step_zero_notice.is_runtime_edit(raw_payload, directory)
+		? lane_child_marker.marked_issue(source)
+		: undefined
+}
+
+function reason(
+	raw_payload: string,
+	directory: string = process.cwd(),
+	source: MarkerSource = process.env,
+): string | undefined {
+	const issue = lane_child_edit(raw_payload, directory, source)
+
+	if (issue === undefined) return undefined
+
+	return lane_plan.is_uncleared(Number(issue), directory) ? reason_text(issue) : undefined
+}
+
+const lane_plan_guard = { reason }
+
+export { lane_plan_guard }

package/scripts/hooks/pre-commit-lint-switch.ts

@@ -0,0 +1,9 @@
+// **Switched off, a pre-commit lint hook neither reserves the core budget nor runs** — set by `josh
+// ship`'s local commit (`run-ship-sync.ts`), whose tree the gate or the scoped pair checks before
+// anything is pushed (joshuafolkken/kit#4985). On by default like every other distributed guard. Its
+// own module because the hook is an entry with a main guard, which nothing may import.
+const SWITCH_ENV_KEY = 'JOSH_PRE_COMMIT_LINT'
+
+const pre_commit_lint_switch = { SWITCH_ENV_KEY }
+
+export { pre_commit_lint_switch }

package/scripts/hooks/pre-commit-lint.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { core_budget } from '#scripts/gate/core-budget'
+import { pre_commit_lint_switch } from '#scripts/hooks/pre-commit-lint-switch'
+import { hook_decision } from '#scripts/josh/hook-decision'
 import {
 	CSPELL_COMMIT_CACHE_FLAGS,
 	ESLINT_COMMIT_CACHE_FILE,
@@ -51,8 +53,13 @@ const TOOL_BUDGETS: Readonly<Record<string, 'spell_check' | 'format' | 'eslint_s
 	eslint: 'eslint_scan',
 }
 
+const SUCCESS_EXIT_CODE = 0
+
 const USAGE = `Usage: josh pre-commit-lint <${Object.keys(TOOL_ARGUMENTS).join('|')}> [files...]`
+const END_OF_OPTIONS = '--'
 
+// The staged files follow `--`, so a file named `--plugin=x.mjs` is read as a file, never as an
+// option that loads code (joshuafolkken/kit#4634).
 function build_arguments(
 	tool: string,
 	staged_files: ReadonlyArray<string>,
@@ -60,7 +67,7 @@ function build_arguments(
 	const tool_arguments = TOOL_ARGUMENTS[tool]
 	if (tool_arguments === undefined) return undefined
 
-	return [...tool_arguments, ...staged_files]
+	return [...tool_arguments, END_OF_OPTIONS, ...staged_files]
 }
 
 // eslint goes through the lane's warm daemon when one is reachable (joshuafolkken/kit#4358): the same
@@ -92,6 +99,10 @@ async function run_reserved(tool: string, staged_files: ReadonlyArray<string>):
 	return await run_tool(command_arguments)
 }
 
+function is_switched_on(): boolean {
+	return hook_decision.is_switch_enabled(pre_commit_lint_switch.SWITCH_ENV_KEY)
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const [tool = '', ...staged_files] = argv
 	const budget = TOOL_BUDGETS[tool]
@@ -102,6 +113,8 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return USAGE_ERROR_EXIT_CODE
 	}
 
+	if (!is_switched_on()) return SUCCESS_EXIT_CODE
+
 	return await core_budget.with_command_reservation(
 		core_budget.CORE_WEIGHTS[budget],
 		async () => await run_reserved(tool, staged_files),

package/scripts/hooks/pre-push-related-switch.ts

@@ -0,0 +1,10 @@
+// **Switched on, a pre-push unit run the gate record does not cover runs the related tests rather than
+// the whole suite** — set by `josh ship`'s push ahead of the gate (`run-ship-sync.ts`), whose gate over
+// the same tree runs the whole suite next (joshuafolkken/kit#5067). Off by default. Its own module
+// because the hook is an entry with a main guard, which nothing may import.
+const SWITCH_ENV_KEY = 'JOSH_PRE_PUSH_RELATED'
+const SWITCH_ON = '1'
+
+const pre_push_related_switch = { SWITCH_ENV_KEY, SWITCH_ON }
+
+export { pre_push_related_switch }

package/scripts/hooks/pre-push-unit.ts

@@ -5,7 +5,10 @@ import { gate_plan } from '#scripts/gate/gate-plan'
 import { gate_skip, type GateReuse } from '#scripts/gate/gate-skip'
 import { gate_tree, type GateTree } from '#scripts/gate/gate-tree'
 import { hook_gate_reuse } from '#scripts/gate/hook-gate-reuse'
+import type { PushMissRecord } from '#scripts/lane/lane-ledger-schema'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 import { test_unit_guard } from '#scripts/test/test-unit-guard'
+import { pre_push_related_switch } from './pre-push-related-switch'
 
 // The pre-push hook's unit run, which does not re-run a suite a green gate already covers: the gate
 // writes its record down, and re-running `vitest run` on a tree it just printed green is the bulk of
@@ -125,30 +128,93 @@ function format_miss(reason: string): string {
 	return `↻ running the whole unit suite — the green gate record does not cover this push: ${reason}.`
 }
 
-// **The whole suite claims its place in the core budget, the one `josh test:unit` claims.** Without it
-// a push's suite ran beside other lanes' gates off the ledger, so their admission saw its workers only
-// as foreign load (joshuafolkken/kit#3874). Only the miss reserves: a reused record runs nothing, and a
+// **A unit run claims its place in the core budget, the one `josh test:unit` claims.** Without it a
+// push's run went beside other lanes' gates off the ledger, so their admission saw its workers only as
+// foreign load (joshuafolkken/kit#3874). Only the miss reserves: a reused record runs nothing, and a
 // claim there could make a push wait out a full ledger for a suite it then skips.
-async function run_reserved_suite(vitest_arguments: ReadonlyArray<string>): Promise<number> {
+async function run_reserved(command: string, run: () => Promise<number>): Promise<number> {
 	const claim = gate_plan.DIRECT_UNIT_CLAIM
 
-	return await core_budget.with_command_reservation(
-		claim.core_weight(),
+	return await core_budget.with_command_reservation(claim.core_weight(), run, {
+		memory_mb: claim.memory_mb(),
+		command,
+		is_unit: claim.is_unit_claim,
+	})
+}
+
+async function run_reserved_suite(vitest_arguments: ReadonlyArray<string>): Promise<number> {
+	return await run_reserved(
+		'pre-push test:unit',
 		async () => await test_unit_guard.run_guarded_unit(process.cwd(), vitest_arguments),
-		{ memory_mb: claim.memory_mb(), command: 'pre-push test:unit', is_unit: claim.is_unit_claim },
 	)
 }
 
+// **A push its caller makes ahead of the gate runs the related tests, not the whole suite**
+// (joshuafolkken/kit#5067). `josh ship` pushes the tree its sync merged with the default branch onto an
+// open pull request so CI starts beside the gate, and the gate that follows runs the whole suite over
+// that same tree; the push itself only needs what this branch's change reaches. Only the caller sets
+// it, `--force` and the escape hatch still win, and a narrowed run asked for its own arguments rather
+// than this scope.
+function is_related_requested(extra_arguments: ReadonlyArray<string>): boolean {
+	const { SWITCH_ENV_KEY, SWITCH_ON } = pre_push_related_switch
+
+	if (process.env[SWITCH_ENV_KEY] !== SWITCH_ON || extra_arguments.length > 0) return false
+
+	return !hook_gate_reuse.is_force_requested(FORCE_ENV)
+}
+
+function format_related(reason: string): string {
+	return `↻ running the related unit tests — the push runs ahead of its gate, and the green gate record does not cover it: ${reason}.`
+}
+
+// Imported only on this path, so every other push leaves the import graph `test-related.ts` loads alone.
+async function run_related(): Promise<number> {
+	const { test_related } = await import('#scripts/test/test-related')
+
+	return await run_reserved(
+		'pre-push test:related',
+		async () => await test_related.run_related_tests([]),
+	)
+}
+
+// joshuafolkken/kit#5234: the miss's kind goes to the lane ledger, so `lane:stats` counts the suites a
+// push ran and why beside the gate's own fallbacks.
+async function record_miss(scope: PushMissRecord['scope'], kind: string): Promise<void> {
+	await lane_ledger_write.record_push_miss({ scope, reason: kind })
+}
+
+async function run_miss(
+	reason: string,
+	kind: string,
+	extra_arguments: ReadonlyArray<string>,
+): Promise<number> {
+	if (is_related_requested(extra_arguments)) {
+		process.stdout.write(`${format_related(reason)}\n`)
+		await record_miss('related', kind)
+
+		return await run_related()
+	}
+
+	process.stdout.write(`${format_miss(reason)}\n`)
+	await record_miss('whole', kind)
+
+	return await run_reserved_suite(forwarded_arguments(extra_arguments))
+}
+
 async function run_pre_push_unit(
 	extra_arguments: ReadonlyArray<string> = [],
 	source?: string,
 ): Promise<number> {
-	const reuse = push_reuse(await read_push_tree(), extra_arguments, source)
+	const tree = await read_push_tree()
+	const reuse = push_reuse(tree, extra_arguments, source)
 
 	if ('miss' in reuse) {
-		process.stdout.write(`${format_miss(reuse.miss)}\n`)
+		const kind = hook_gate_reuse.miss_kind(reuse.miss, {
+			carry_miss: tree.carry_miss,
+			force_env: FORCE_ENV,
+		})
 
-		return await run_reserved_suite(forwarded_arguments(extra_arguments))
+		return await run_miss(reuse.miss, kind, extra_arguments)
 	}
 
 	process.stdout.write(`${format_skip(reuse.stamp.taken_at)}\n`)

package/scripts/hooks/pretool-guard.ts

@@ -11,6 +11,7 @@ import { run_poll_hook } from '#scripts/run/run-poll-hook'
 import { run_watcher_hook } from '#scripts/run/run-watcher-hook'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { batch_outcome } from './batch-guard'
+import { lane_plan_guard } from './lane-plan-guard'
 import { shell_rules_notice } from './shell-rules-notice'
 import { step_zero_notice } from './step-zero-notice'
 
@@ -72,6 +73,7 @@ function guard_outcome(raw_payload: string): GuardOutcome {
 		batch_outcome(raw_payload),
 		investigation_outcome(raw_payload),
 		duplicate_read_outcome(raw_payload),
+		{ reason: lane_plan_guard.reason(raw_payload), notice: undefined, fault: undefined },
 	]
 
 	return combine_outcomes(outcomes, delivered_rules.delivery(raw_payload))

package/scripts/hooks/reserved-run.ts

@@ -106,12 +106,25 @@ function reservation_options(parsed: ReservedCommand): {
 	return { command, memory_mb: parsed.memory_mb ?? command_memory.estimated_memory_mb(command) }
 }
 
+// The directory the caller typed the command in. **`pnpm josh` runs from the package root**, so without
+// this a wrapped `eslint rules/a.ts` typed in `scripts/` would lint from the root and match nothing;
+// pnpm records the caller's directory in `INIT_CWD` (joshuafolkken/kit#5147).
+function command_directory(): string {
+	const initial = process.env['INIT_CWD']
+
+	return initial === undefined || initial === '' ? process.cwd() : initial
+}
+
 // `stdio: 'inherit'` so the command's own progress reaches the push, and `reject: false` so a failing
 // command becomes an exit code the caller returns rather than a throw — the reservation is released by
 // `with_core_reservation`'s `finally` on either path.
 async function run_command(command: ReadonlyArray<string>): Promise<number> {
 	const [file = '', ...args] = command
-	const result = await execa(file, args, { stdio: 'inherit', reject: false })
+	const result = await execa(file, args, {
+		cwd: command_directory(),
+		stdio: 'inherit',
+		reject: false,
+	})
 
 	return result.exitCode ?? FAIL_EXIT_CODE
 }

package/scripts/hooks/run-hook.sh

@@ -22,23 +22,38 @@
 #   `dirname`, and `node` replaces this shell through `exec` rather than running beside it.
 # - An `if`/`else`, never `&&`/`||`: a guard's refusal is a non-zero exit, and a chain would read it as
 #   a missing bundle and run the hook twice.
-
-location_variables='GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE'
-if [ -n "$GIT_ALTERNATE_OBJECT_DIRECTORIES$GIT_COMMON_DIR$GIT_DIR$GIT_INDEX_FILE$GIT_NAMESPACE$GIT_OBJECT_DIRECTORY$GIT_WORK_TREE" ] &&
-	(unset $location_variables && git rev-parse --show-toplevel >/dev/null 2>&1); then
-	unset $location_variables
-fi
+# - A hook launched inside one of Claude Code's own worktrees (`EnterWorktree`, an
+#   `isolation: "worktree"` subagent) runs in that worktree. Claude Code keeps `CLAUDE_PROJECT_DIR` on
+#   the main checkout there, so the prefix lands on it and hands over where the hook was launched in
+#   `JOSH_HOOK_CWD` (joshuafolkken/kit#4617). The code still comes from the project root — a fresh
+#   worktree has no install and no bundles — so only the working directory moves.
 
 hook_name=$1
 shift
 case $0 in
-*/*) hooks_dir=${0%/*} ;;
-*) hooks_dir=. ;;
+/*) hooks_dir=${0%/*} ;;
+*/*) hooks_dir=$PWD/${0%/*} ;;
+*) hooks_dir=$PWD ;;
 esac
 package_dir="$hooks_dir/../.."
 bundle="$package_dir/dist/hooks/$hook_name.js"
 josh_command="${hook_name%%-*}:${hook_name#*-}"
 
+worktrees_dir=$PWD/.claude/worktrees/
+case $JOSH_HOOK_CWD in
+"$worktrees_dir"?*)
+	worktree_path=${JOSH_HOOK_CWD#"$worktrees_dir"}
+	cd "$worktrees_dir${worktree_path%%/*}" || exit
+	;;
+*) ;;
+esac
+
+location_variables='GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE'
+if [ -n "$GIT_ALTERNATE_OBJECT_DIRECTORIES$GIT_COMMON_DIR$GIT_DIR$GIT_INDEX_FILE$GIT_NAMESPACE$GIT_OBJECT_DIRECTORY$GIT_WORK_TREE" ] &&
+	(unset $location_variables && git rev-parse --show-toplevel >/dev/null 2>&1); then
+	unset $location_variables
+fi
+
 case $0 in
 *node_modules/*)
 	if [ -d "$package_dir/dist/hooks" ]; then exec node "$bundle" "$@"; else exec node "$package_dir/dist/josh.js" "$josh_command" "$@"; fi

package/scripts/hooks/step-zero-notice.ts

@@ -58,6 +58,11 @@ function is_candidate(raw_payload: string, root: string): string | undefined {
 	return has_runtime_file ? payload.transcript_path : undefined
 }
 
+// Whether the payload edits a runtime file under `root` — the edit Step 0 and the lane plan precede.
+function is_runtime_edit(raw_payload: string, root: string = process.cwd()): boolean {
+	return is_candidate(raw_payload, root) !== undefined
+}
+
 function notice(raw_payload: string, root: string = process.cwd()): string | undefined {
 	const transcript = is_candidate(raw_payload, root)
 
@@ -72,6 +77,6 @@ function notice(raw_payload: string, root: string = process.cwd()): string | und
 	return NOTICE
 }
 
-const step_zero_notice = { NOTICE, notice, stamp_path: STAMP.path }
+const step_zero_notice = { NOTICE, is_runtime_edit, notice, stamp_path: STAMP.path }
 
 export { step_zero_notice }

package/scripts/hooks/stop-actions.ts

@@ -1,12 +1,10 @@
 import { git_gh_repo } from '#scripts/gh/git-gh-repo'
 import { issue_cite } from '#scripts/issue/issue-cite'
-import { issue_cite_cli } from '#scripts/issue/issue-cite-cli'
 import { session_cite } from '#scripts/issue/session-cite'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
 import { stdout_on_stderr } from '#scripts/lib/stdout-on-stderr'
 import { telegram_test } from '#scripts/notify/telegram-test'
 import type { CliValues } from '#scripts/notify/telegram-test-logic'
-import { issue_citation } from '#scripts/rules/issue-citation'
 import { stop_rules, type StopAction, type StopOutcome } from '#scripts/rules/stop-rules'
 import { run_hold } from '#scripts/run/hold/run-hold'
 import { run_hold_cli } from '#scripts/run/hold/run-hold-cli'
@@ -15,9 +13,8 @@ import { run_hold_session } from '#scripts/run/hold/run-hold-session'
 type NotifyAction = Extract<StopAction, { kind: 'notify' }>
 
 // The `Stop` hook running the operations whose answer is fixed (joshuafolkken/kit#3919): the
-// `confirmation` notify, the hold release and the citation lines, through the very calls
-// `josh notify`, `josh run:release` and `josh issue:cite` make — in process, since three `pnpm`
-// launches would spend most of the hook's 20-second budget. What each did reaches the person as a
+// `confirmation` notify and the hold release, through the very calls `josh notify` and
+// `josh run:release` make — in process, since two `pnpm` launches would spend most of the hook's 20-second budget. What each did reaches the person as a
 // `systemMessage`; one that did not take falls back to the refusal it replaced (`stop_rules.fallback_reason`).
 
 const SUCCESS_EXIT_CODE = 0
@@ -109,20 +106,11 @@ async function release(issue: string): Promise<string | undefined> {
 	return code === SUCCESS_EXIT_CODE ? '🔓 stop:guard released the run:hold record.' : undefined
 }
 
-// Every line or none: a citation with a number missing is the half-fix the refusal exists to avoid.
-async function cite(references: ReadonlyArray<string>): Promise<string | undefined> {
-	const cited = await issue_cite_cli.cite(issue_citation.cite_arguments(references))
-	if (cited === undefined || cited.failures.length > 0) return undefined
-
-	return ['Issue citations:', ...cited.lines].join(NOTICE_SEPARATOR)
-}
-
 // An action's line for the person, or `undefined` when it did not take.
 async function run_action(action: StopAction): Promise<string | undefined> {
 	if (action.kind === 'notify') return await notify(action)
-	if (action.kind === 'release') return await release(action.issue)
 
-	return await cite(action.references)
+	return await release(action.issue)
 }
 
 // A throw is an action that did not take, the same as one that answered it had failed.

package/scripts/hooks/stop-guard.ts

@@ -10,7 +10,6 @@ import { session_language } from '#scripts/josh/session-language'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { lane_handoff } from '#scripts/lane/lane-handoff'
 import { stdout_on_stderr } from '#scripts/lib/stdout-on-stderr'
-import { filing_cap } from '#scripts/rules/filing-cap'
 import { lane_background } from '#scripts/rules/lane-background'
 import { lane_park } from '#scripts/rules/lane-park'
 import { last_prompt } from '#scripts/rules/last-prompt'
@@ -18,6 +17,7 @@ import { pre_gate_cut } from '#scripts/rules/pre-gate-cut'
 import { stop_decision } from '#scripts/rules/stop-decision'
 import { stop_rules, type StopContext, type StopOutcome } from '#scripts/rules/stop-rules'
 import { tail_commands } from '#scripts/rules/tail-commands'
+import { turn_filings } from '#scripts/rules/turn-filings'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_cut } from '#scripts/run/cut/run-cut'
 import { run_cut_report } from '#scripts/run/cut/run-cut-report'
@@ -82,10 +82,10 @@ function transcript_tail(transcript_path: string): string {
 	return time_density_hook.read_tail(transcript)
 }
 
-// An Issue was filed on this turn — the tail from the last prompt on. The count is `filing_cap`'s, so a
-// filing a guard refused is not counted, and one an earlier turn made does not stand this turn down.
+// An Issue was filed on this turn — the tail from the last prompt on. The count is `turn_filings`', so
+// a filing a guard refused is not counted, and one an earlier turn made does not stand this turn down.
 function was_filed(tail: string): boolean {
-	return filing_cap.turn_filing_count(tail) > 0
+	return turn_filings.turn_filing_count(tail) > 0
 }
 
 // This turn ended at a cut — a record still `carried`, or this turn's `run:cut` relaunching a successor.
@@ -95,7 +95,7 @@ function is_cut_stop(tail: string): boolean {
 	if (run_cut.carried_cut_sync() !== undefined) return true
 
 	return tail_commands.answered(
-		filing_cap.current_turn(tail),
+		turn_filings.current_turn(tail),
 		pre_gate_cut.takes_the_cut,
 		run_cut_report.RELAUNCHED_CUT_MARKER,
 	)
@@ -129,7 +129,7 @@ async function build_context(
 		...(await hold_facts(tail)),
 		tree_clean: !(await run_hold.is_tree_dirty()),
 		message: payload_tail.message,
-		prompt: last_prompt.prompt_text(tail),
+		prompt: last_prompt.person_prompt(tail),
 		answers_question: stop_decision.is_question(last_prompt.turn_prompt(tail)),
 		stop_hook_active: payload_tail.stop_hook_active,
 		cut_pending: is_cut_stop(tail),
@@ -139,6 +139,7 @@ async function build_context(
 		headless_refusals: stop_rules.count_headless_refusals(tail),
 		background_pending: lane_background.pending_background_ids(tail).length > 0,
 		agent_pending: lane_background.pending_agent_ids(tail).length > 0,
+		command_pending: lane_background.pending_command_ids(tail).length > 0,
 		handed_off: lane_handoff.is_handed_off(process.cwd()),
 		session_lang: session_lang(),
 	}

package/scripts/init/distributed-paths.ts

@@ -124,6 +124,7 @@ const distributed_paths = {
 	ensure_claude_md_import,
 	remove_claude_md_import,
 	CLAUDE_MD_IMPORT_LINE,
+	KIT_PACKAGE_PATH_PREFIX,
 }
 
 export { distributed_paths }

package/scripts/init/hook-command-rewrite.ts

@@ -56,9 +56,13 @@ const LOCATION_VARIABLES =
 	'GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE'
 const ROOT_LOOKUP = 'git rev-parse --show-toplevel'
 const LEGACY_ROOT_PREFIX = `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP})"; fi && cd "$project_root" && `
+// The root prefix kit wrote until joshuafolkken/kit#4617 exported the launch directory for a worktree.
+// History, never edited; removable from kit 2.0.0.
+const PRE_WORKTREE_ROOT_PREFIX = `project_root="\${CLAUDE_PROJECT_DIR:-$( (unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP} 2>/dev/null) || ${ROOT_LOOKUP})}" && cd "$project_root" && `
 // The values below are matched inside raw JSON text, so each root prefix is taken in its escaped form.
 const ROOT_PREFIXES: ReadonlyArray<string> = [
 	hook_launch.PROJECT_ROOT_PREFIX,
+	PRE_WORKTREE_ROOT_PREFIX,
 	LEGACY_ROOT_PREFIX,
 ].map((prefix) => JSON.stringify(prefix).slice(1, -1))
 const [PROJECT_ROOT_PREFIX = ''] = ROOT_PREFIXES
@@ -87,7 +91,7 @@ function rewrite_command_value(value: string): string {
 }
 
 // kit's own commands already start from the root (`hook-launch.ts`), and so does an already-rewritten
-// value. The prefix — the current one or the one before it — is taken off before the rewrite and the
+// value. The prefix — the current one or an earlier one — is taken off before the rewrite and the
 // current one put back after it, so the install guard sits behind the `cd` it depends on and a second
 // pass never doubles the prefix.
 function without_root_prefix(value: string): string {

package/scripts/init/hook-launch.ts

@@ -10,7 +10,9 @@
 // first without the git location variables a git hook leaks, since a relative or bare `GIT_DIR` read
 // from a subdirectory names the wrong work tree, and with them only when the checkout does not resolve
 // without them (its metadata lives outside the work tree). A lookup that fails ends the command before
-// the launcher (joshuafolkken/kit#4187).
+// the launcher (joshuafolkken/kit#4187). Inside one of Claude Code's own worktrees `CLAUDE_PROJECT_DIR`
+// still names the main checkout, so the prefix exports where the hook was launched as `JOSH_HOOK_CWD`
+// and the launcher moves the hook's working directory into that worktree (joshuafolkken/kit#4617).
 //
 // **Everything after the root is one script** (`scripts/hooks/run-hook.sh`): the git location
 // variables a git hook exports, the bundle-ready gate and the live-source fallback live there once, so
@@ -23,7 +25,7 @@ const HOOK_DIST_DIR = 'dist/hooks'
 const RUN_HOOK_SCRIPT = 'scripts/hooks/run-hook.sh'
 const ROOT_LOOKUP = 'git rev-parse --show-toplevel'
 const CODEX_ROOT = `$( (unset ${GIT_LOCATION_VARIABLES.join(' ')}; ${ROOT_LOOKUP} 2>/dev/null) || ${ROOT_LOOKUP})`
-const PROJECT_ROOT_PREFIX = `project_root="\${CLAUDE_PROJECT_DIR:-${CODEX_ROOT}}" && cd "$project_root" && `
+const PROJECT_ROOT_PREFIX = `export JOSH_HOOK_CWD="$PWD" && project_root="\${CLAUDE_PROJECT_DIR:-${CODEX_ROOT}}" && cd "$project_root" && `
 
 // `name` is the hook's bundle under `dist/hooks` without `.js` (e.g. `pretool-guard`), followed by any
 // arguments it takes (e.g. `codex-hook-adapter pretool`).

package/scripts/issue/aggregation-split.ts

@@ -0,0 +1,52 @@
+import { markdown_section } from './markdown-section'
+import { size_estimate } from './size-estimate'
+
+// joshuafolkken/kit#5190: #5162 carried "aggregate the transcripts and record it as an Issue comment"
+// beside a six-file implementation; the aggregation's output filled the lane's context before the
+// implementation began and cut the session. The aggregation is a mergeable result of its own, so a body
+// asking for both is refused and the aggregation routed to a prior `--route split` Issue — the
+// implementation Issue then starts from the comment it cites.
+
+const CRITERIA_HEADING = '## 受け入れ条件'
+const CRITERION_PREFIX = '- ['
+// Recording on an Issue, not a feature that posts a PR comment: every one of these words names the
+// lane's own act.
+const RECORDING_WORDS: ReadonlyArray<string> = ['Issue', 'コメント', '記録']
+// What is recorded: an aggregation, or a measurement — #5202's before / after reach count, which carried
+// no aggregation word and passed (joshuafolkken/kit#5238). One of them is enough.
+const SUBJECT_WORDS: ReadonlyArray<string> = ['集計', '計測', 'before', '変更前後']
+// A criterion citing the prior aggregation Issue is the implementation this rule asks for.
+const ISSUE_REFERENCE = /#\d+/u
+// The implementation the estimate declares: a prior aggregation Issue may add a script or two of its own.
+const IMPLEMENTATION_FILES = 3
+const REFUSAL = `an acceptance criterion records an aggregation or a measurement as an Issue comment beside an implementation of ${String(IMPLEMENTATION_FILES)}+ files — file it as a prior Issue (\`--route split\`) and cite its comment under ## 背景 in this one; issue-template.md → "\`## 背景\` 直下の宣言と分類ラベル"`
+
+function is_aggregation_criterion(line: string): boolean {
+	const text = line.trim()
+
+	if (!text.startsWith(CRITERION_PREFIX) || ISSUE_REFERENCE.test(text)) return false
+
+	return (
+		SUBJECT_WORDS.some((word) => text.includes(word)) &&
+		RECORDING_WORDS.every((word) => text.includes(word))
+	)
+}
+
+function has_aggregation_criterion(body: string): boolean {
+	const criteria = markdown_section.section_lines(body, CRITERIA_HEADING).join('\n')
+
+	return markdown_section.unfenced_lines(criteria).some((line) => is_aggregation_criterion(line))
+}
+
+function declares_implementation(body: string): boolean {
+	return (size_estimate.declared_files(body) ?? 0) >= IMPLEMENTATION_FILES
+}
+
+// The refusal for a body carrying both; empty for an aggregation alone or an implementation alone.
+function problems(body: string): ReadonlyArray<string> {
+	return has_aggregation_criterion(body) && declares_implementation(body) ? [REFUSAL] : []
+}
+
+const aggregation_split = { IMPLEMENTATION_FILES, problems }
+
+export { aggregation_split }