@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/josh/josh-usage-workflow.ts

@@ -0,0 +1,212 @@
+import type { CommandUsage } from './josh-command-types'
+
+// The usage of the commands `docs/josh-commands-automation.md` documents under "Workflow",
+// "Versioning", "Maintenance" and "Git hooks", keyed by command name. The page's usage blocks are
+// generated from this table and `josh help <command>` prints it, so an example or a flag is written
+// once, here (#3939).
+const PR_TITLE = '"PR title #N"'
+const ISSUE_URL = '--issue-url "https://..."'
+const REVIEW_ISSUE = '--issue 2325'
+const CHECK = '--check'
+const JSON_FLAG = '--json'
+const BODY_FILE_NOTE =
+	'(`-` reads stdin); use this whenever the body carries a backtick or `$`. Passing both forms is refused.'
+
+/* eslint-disable @typescript-eslint/naming-convention */
+const WORKFLOW_USAGE: Readonly<Record<string, CommandUsage>> = {
+	followup: {
+		examples: [
+			{ arguments: PR_TITLE, note: 'merges (default)' },
+			{ arguments: String.raw`${PR_TITLE} --notify-message "Implemented X:\n- change 1"` },
+			{ arguments: `${PR_TITLE} --notify-message-file completion.md` },
+			{ arguments: `${PR_TITLE} --ai-review-ignore-reason "false positive"` },
+			{ arguments: `${PR_TITLE} --no-merge`, note: 'do the work, leave the PR open' },
+		],
+		flags: [
+			{
+				names: ['--no-merge'],
+				description:
+					'do the follow-up work but do not merge; leaves the PR open (the only flag that stops the merge). `--merge` is a deprecated no-op. A PR already merged by hand skips the CI wait, the AI-review scan and the merge and runs only the post-merge tail; a completion report already on the Issue is not posted again.',
+			},
+			{
+				names: ['--notify-message'],
+				description: 'inline completion body; `\\n` expands to newlines.',
+			},
+			{
+				names: ['--notify-message-file'],
+				description: `read the completion body from a file ${BODY_FILE_NOTE}`,
+			},
+			{
+				names: ['--ai-review-ignore-reason'],
+				description: 'reason to dismiss an AI-review finding.',
+			},
+		],
+	},
+	notify: {
+		examples: [
+			{ arguments: String.raw`--task-type planning ${ISSUE_URL} --body="- bullet 1\n- bullet 2"` },
+			{
+				arguments: `--task-type confirmation ${ISSUE_URL} --body-file r.md --recommended "Go" --alternative "Wait"`,
+			},
+		],
+		flags: [
+			{
+				names: ['--task-type'],
+				description:
+					'one of `planning` 📋, `completion` ✅, `failure` ❌, `warning` ⚠️, `kickoff_retry` 🔄, `confirmation` ⏸️. Do not send `completion` or `warning` by hand — `josh followup` sends them.',
+			},
+			{
+				names: ['--body', "--body=$'…'"],
+				description: "inline body; use `--body=$'…'` when it starts with `-`.",
+			},
+			{ names: ['--body-file'], description: `read the body from a file ${BODY_FILE_NOTE}` },
+			{
+				names: ['--repo-name', '--issue-url', '--pr-url'],
+				description:
+					'header repository, resolved in that order, then the working directory. The issue title is read from `--issue-url`.',
+			},
+			{
+				names: ['--recommended', '--alternative'],
+				description:
+					'the choices appended under `JOSH_SESSION_LANG` headings; `--recommended` is required for `confirmation`, `--alternative` is repeatable.',
+			},
+		],
+	},
+	'observations:flush': { examples: [{ arguments: '' }] },
+	'measure:rerun': { examples: [{ arguments: '2212' }] },
+	'review:record': {
+		examples: [
+			{ arguments: `${REVIEW_ISSUE} bug-risks:medium:src/foo.ts:42 tests:low:a.test.ts` },
+			{ arguments: REVIEW_ISSUE, note: 'a zero-finding round — records one `none` line' },
+			{
+				arguments: `${REVIEW_ISSUE} --comment`,
+				note: 'a round that passed after the PR opened — an Issue comment, no append',
+			},
+			{ arguments: `${CHECK} ${REVIEW_ISSUE}`, note: 'the merge gate: was it recorded?' },
+		],
+	},
+	bump: { examples: [{ arguments: 'major' }, { arguments: 'minor' }, { arguments: 'patch' }] },
+	release: {
+		examples: [
+			{ arguments: '' },
+			{ arguments: '--dry-run', note: 'count and report, write nothing' },
+		],
+		flags: [
+			{
+				names: ['--dry-run'],
+				description:
+					'count and report only; writes nothing, fetches nothing, and creates no work tree.',
+			},
+			{
+				names: ['--help', '-h'],
+				description:
+					'print the usage line and exit 0 without fetching or releasing. Any other argument is refused with the usage line and a non-zero exit, before anything is fetched.',
+			},
+		],
+	},
+	'release:scope': {
+		examples: [
+			{ arguments: '', note: '→ required | skip | unknown' },
+			{ arguments: '--json', note: '{"scope":"…","reason":"…"} on one line' },
+		],
+	},
+	'ruleset:check': {
+		examples: [
+			{ arguments: '', note: 'report only' },
+			{ arguments: '--apply', note: 'add the missing checks to the existing rule' },
+		],
+		flags: [
+			{
+				names: ['--apply'],
+				description:
+					"append the missing checks to the ruleset's required-checks rule (or to the branch protection's contexts). It never creates a ruleset: with none, create one under Settings → Rules → Rulesets, then rerun. Writing a repository setting needs admin access, so only this flag writes — `josh sync` and `josh doctor` never do.",
+			},
+		],
+	},
+	'audit:provision': {
+		examples: [
+			{ arguments: '', note: 'no-op if a scanner is already present' },
+			{ arguments: '--force', note: 'ignore backoff, allow a longer download' },
+		],
+		flags: [
+			{
+				names: ['--force'],
+				description:
+					'ignore the 6-hour failure backoff and allow a longer download window; the command to run after fixing a network problem.',
+			},
+		],
+	},
+	'reconcile-templates': {
+		examples: [
+			{ arguments: '', note: 'regenerate copy templates + record tripwire hashes' },
+			{ arguments: CHECK, note: 'verify templates are in sync; non-zero on drift' },
+		],
+		flags: [
+			{
+				names: [CHECK],
+				description:
+					'verify only; exits non-zero on drift. A pre-commit hook runs this when a tracked source or copy template is staged.',
+			},
+		],
+	},
+	'pre-push-unit': { examples: [{ arguments: '' }] },
+	'reserved-run': {
+		examples: [
+			{ arguments: '2 -- pnpm install', note: 'hold 2 cores while installing' },
+			{ arguments: '1 -- pnpm josh audit', note: 'hold 1 core while scanning' },
+		],
+	},
+	'pre-commit-type-check': { examples: [{ arguments: '' }] },
+	'pr:classification': {
+		examples: [{ arguments: '', note: 'run by CI on a pull request; fails without one label' }],
+	},
+	'observation:record': {
+		examples: [
+			{ arguments: "flaky-e2e d1 'tests/e2e/login.test.ts' 'times out on CI only'" },
+			{
+				arguments: "flaky-e2e d1 'src/app.ts' 'fails there too' --checkout ~/Development/app",
+				note: "another repository's ledger",
+			},
+		],
+		flags: [
+			{
+				names: ['--checkout <path>'],
+				description: "count and append in that repository's `.josh/observations/` instead.",
+			},
+		],
+	},
+	'release:github': {
+		examples: [
+			{ arguments: '', note: 'run by CI with GH_TOKEN, RELEASE_TAG and GITHUB_REPOSITORY set' },
+		],
+	},
+	'latest:scope': {
+		examples: [
+			{ arguments: '', note: 'required or skip, the reason on stderr' },
+			{ arguments: '--record', note: 'note a finished josh latest run' },
+			{ arguments: JSON_FLAG, note: 'the verdict and the reason as JSON' },
+		],
+		flags: [
+			{ names: ['--record'], description: 'write the completion record `josh latest` ends with.' },
+			{ names: [JSON_FLAG], description: 'emit the verdict and its reason as JSON.' },
+		],
+	},
+	'latest:guard': { examples: [{ arguments: '', note: 'refuses inside a lane' }] },
+	'prevent-main-commit': { examples: [{ arguments: '', note: 'run by the pre-commit hook' }] },
+	'check-commit-message': {
+		examples: [{ arguments: '.git/COMMIT_EDITMSG', note: 'run by the commit-msg hook' }],
+	},
+	'secretlint-scan': {
+		examples: [{ arguments: 'src/app.ts .env.example', note: 'the staged paths' }],
+	},
+	'pre-commit-lint': {
+		examples: [
+			{ arguments: 'cspell src/app.ts' },
+			{ arguments: 'prettier src/app.ts' },
+			{ arguments: 'eslint src/app.ts' },
+		],
+	},
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export { WORKFLOW_USAGE }

package/scripts/josh/josh.ts

@@ -1,4 +1,5 @@
 import { doctor_consumer } from '#scripts/doctor/doctor-consumer'
+import { command_usage } from './command-usage'
 import { find_package_directory, josh_logic, UNKNOWN_COMMAND_EXIT_CODE } from './josh-logic'
 
 const ARGV_OFFSET = 2
@@ -12,10 +13,6 @@ const HELP_COMMANDS: ReadonlySet<string> = new Set(['help', '--help', '-h'])
 // A bare `--all` in the command slot is a help request, not a command.
 const ALL_FLAG = '--all'
 
-function print_help(is_all: boolean, is_consumer: boolean): void {
-	console.info(josh_logic.format_help(is_all, is_consumer))
-}
-
 // Both halves go to stderr. The help listing is a diagnosis here, not the answer, and a shell
 // wiring `--port $(josh port dev)` reads stdout alone, so a command name this kit cannot resolve
 // has to leave that stream empty rather than substitute the whole toolkit index (#825).
@@ -24,6 +21,18 @@ function handle_unknown(cmd: string): never {
 	process.exit(1)
 }
 
+// `josh help <command>` prints that one command's usage — the text its reference page renders
+// (#3932); a flag in the topic slot is still a listing request (`josh --help --all`).
+function print_help(is_all: boolean, is_consumer: boolean, topic: string | undefined): void {
+	if (topic === undefined || topic.startsWith('-')) {
+		console.info(josh_logic.format_help(is_all, is_consumer))
+
+		return
+	}
+
+	console.info(command_usage.format_command_help(topic) ?? handle_unknown(topic))
+}
+
 // `process.exit` truncates a piped stdout at its buffer size, and the output at risk is the script's
 // own — `scripts/gate/verification-gate.ts` writes its per-check blocks
 // and its failure summary through this process, and sets `process.exitCode` rather than exiting for
@@ -44,7 +53,7 @@ async function main(): Promise<void> {
 	const is_consumer = doctor_consumer.is_kit_consumer(find_package_directory(process.cwd()))
 
 	if (!cmd || cmd === ALL_FLAG || HELP_COMMANDS.has(cmd)) {
-		print_help(is_all, is_consumer)
+		print_help(is_all, is_consumer, process.argv[ARGV_OFFSET + 1])
 
 		return
 	}

package/scripts/josh/package-directory.ts

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { ancestor_directories } from '#scripts/lib/ancestor-directories'
+
+const PACKAGE_JSON = 'package.json'
+
+// Resolve the kit package root by ascending to the nearest package.json. This works both
+// from the bundled dist/josh.js (one level under the root) and from the tsx source at
+// scripts/josh/ (two levels), so this file's depth no longer has to be hard-coded.
+// A leaf apart from `josh-logic`, so a bundled command can import it without pulling the
+// dispatcher's main-guarded closure into its single-file bundle.
+function find_package_directory(start_directory: string): string {
+	return (
+		ancestor_directories.nearest(start_directory, (directory) =>
+			existsSync(path.join(directory, PACKAGE_JSON)),
+		) ?? start_directory
+	)
+}
+
+export { find_package_directory }

package/scripts/lane/lane-await.ts

@@ -89,8 +89,9 @@ function process_trace_default(issue: string): ProcessTrace {
 
 	process_tools.throw_if_missing(PGREP_COMMAND, result.error)
 
-	if (result.status === PROCESS_FOUND) return PROCESS_ALIVE
-	if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE
+	if (result.status === PROCESS_FOUND || lane_handoff.is_ship_running(issue, process.cwd())) {
+		return PROCESS_ALIVE
+	}
 
 	return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN
 }

package/scripts/lane/lane-capacity.ts

@@ -73,8 +73,14 @@ function seated_limit(limit: number): number {
 // Never negative: a repository holding more `in-progress` issues than the limit allows — the limit
 // was lowered, or a stale label outlived its run — has no free lane, and a negative count read as
 // "how many to offer" would be a slice nobody meant.
-function free_lanes(limit: number, occupied: number): number {
-	return Math.max(NO_LANES, seated_limit(limit) - occupied)
+//
+// **A lane that holds no place under the limit still holds its port seat** (joshuafolkken/kit#3967):
+// `seated` counts every open lane, so the free count never offers more launches than seats are left.
+function free_lanes(limit: number, occupied: number, seated = occupied): number {
+	const by_limit = seated_limit(limit) - occupied
+	const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated
+
+	return Math.max(NO_LANES, Math.min(by_limit, by_seats))
 }
 
 const lane_capacity = {

package/scripts/lane/lane-check-stats.ts

@@ -0,0 +1,56 @@
+import { lane_ledger, type GateCheckRecord, type GateEntry, type LedgerEntry } from './lane-ledger'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// Which check a gate waited on: the ledger's per-check rows of one period reduced to one row per check
+// — median, maximum, how many runs and how many were reused — printed last by `josh lane:stats`. The
+// rows are in the order the checks first appear.
+//
+// **A reused check is counted, never timed.** It started no process, so its zero would pull the median
+// toward a check that never ran; a check with only reused rows prints `not measured`.
+
+const MS_PER_SECOND = 1000
+const DECIMALS = 1
+const COLUMNS = ['check', 'median (s)', 'max (s)', 'runs', 'reused'] as const
+
+function is_gate(entry: LedgerEntry): entry is GateEntry {
+	return entry.kind === lane_ledger.KIND.GATE
+}
+
+function cell(milliseconds: number | undefined): string {
+	return milliseconds === undefined
+		? lane_stage_stats.NOT_MEASURED
+		: (milliseconds / MS_PER_SECOND).toFixed(DECIMALS)
+}
+
+function check_row(label: string, checks: ReadonlyArray<GateCheckRecord>): string {
+	const runs = checks.filter((check) => check.label === label)
+	const timed = runs.filter((check) => check.is_reused !== true).map((check) => check.elapsed_ms)
+
+	return lane_stats.to_row([
+		label,
+		cell(lane_stats.median(timed)),
+		cell(lane_stats.peak(timed)),
+		String(runs.length),
+		String(runs.length - timed.length),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const checks = lane_stats
+		.in_window(entries, window)
+		.filter(is_gate)
+		.flatMap((gate) => gate.checks ?? [])
+	const labels = [...new Set(checks.map((check) => check.label))]
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...labels.map((label) => check_row(label, checks)),
+	].join('\n')
+}
+
+const lane_check_stats = { table }
+
+export { lane_check_stats }

package/scripts/lane/lane-child-invocation.ts

@@ -1,13 +1,19 @@
+import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { run_ship_next, type ShipResume } from '#scripts/run/ship/run-ship-next'
 import type { Stage } from '#scripts/run/ship/run-ship-stage'
+import { run_ship_stop_context, type StopContext } from '#scripts/run/ship/run-ship-stop-context'
 
 interface ShipStop extends ShipResume {
 	stage: Stage
+	context?: StopContext
 }
 
 const CHILD_INVOCATION = 'fullrun'
+const LINE_BREAK = '\n'
+// What a brokered reviewer's prompt ends with, so the one pattern below finds it too.
+const REVIEW_INVOCATION = 'the reviewer of lane'
 const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
 // What a detached `josh ship --detach` supervisor's command line carries. It ends
 // with the `"<title> #<N>"` title on purpose, so the liveness pattern below finds it by the same trailing
@@ -31,10 +37,20 @@ function child_invocation(issue: string): string {
 // pattern stopped matching as finished — parking an issue that was still shipping. The supervisor's
 // command line ends with its `#<N>` title, so the one extended pattern covers both, and the wait, the
 // liveness read and the reaper keep searching with a single pattern.
+//
+// **A brokered reviewer counts as the child too** (joshuafolkken/kit#3878). The lane's broker starts it
+// for a ship and it outlives a ship that stopped waiting: unmatched, the lane read as finished, the
+// run parked the issue under it, and the reap left it running checks in the parked lane.
 function process_pattern(issue: string): string {
 	issue_number_shape.require_issue_number(issue)
 
-	return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
+	return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
+}
+
+function review_invocation(issue: string): string {
+	issue_number_shape.require_issue_number(issue)
+
+	return `${REVIEW_INVOCATION} ${issue_cite.plain(issue)}`
 }
 
 function resume_invocation(issue: string): string {
@@ -67,14 +83,41 @@ function outage_resume_invocation(issue: string): string {
 // **A known stage puts the next command in the prompt**, so the relaunched
 // session runs it rather than re-deriving it from `chain-rule.md`. An OpenAI lane's supervisor sees only
 // that the ship failed, not where, so without a stage the prompt points at `run:step` as before.
+//
+// **A stop that carries its context puts it in the prompt too** — the failed output's
+// tail and the changed files (`run-ship-stop-context.ts`), so the session starts at the fix rather than
+// at `josh ship --log` and `git diff` (joshuafolkken/kit#3923).
+//
+// The context gets what the rest of the prompt leaves of the one argv element's cap, so the whole
+// prompt still launches (joshuafolkken/kit#3964).
+function known_stop_lines(
+	issue: string,
+	stop: ShipStop,
+	frame: ReadonlyArray<string>,
+): ReadonlyArray<string> {
+	const { context } = stop
+	const is_excerpted = run_ship_stop_context.has_excerpt(context)
+	const next = run_ship_next.next_step(issue, stop.stage, stop, is_excerpted)
+
+	if (context === undefined) return [next]
+
+	const fixed = [...frame, next].join(LINE_BREAK).length + LINE_BREAK.length
+	const budget = agent_role_profile.MAX_VALUE_LENGTH - fixed
+
+	return [next, run_ship_stop_context.describe(issue, context, budget)]
+}
+
 function ship_stop_invocation(issue: string, stop?: ShipStop): string {
 	const opening = `Resuming the lane child for issue ${issue_cite.plain(issue)} after its detached ship supervisor stopped at a failed stage — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`
-	const next =
+	const closing = `Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`
+	const middle =
 		stop === undefined
-			? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
-			: run_ship_next.next_step(issue, stop.stage, stop)
+			? [
+					`Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`,
+				]
+			: known_stop_lines(issue, stop, [opening, closing])
 
-	return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`
+	return [opening, ...middle, closing].join(LINE_BREAK)
 }
 
 const lane_child_invocation = {
@@ -82,6 +125,7 @@ const lane_child_invocation = {
 	outage_resume_invocation,
 	process_pattern,
 	resume_invocation,
+	review_invocation,
 	ship_stop_invocation,
 }
 

package/scripts/lane/lane-dispatch.ts

@@ -7,7 +7,7 @@ import { IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { session_cite } from '#scripts/issue/session-cite'
 import { telegram_notify } from '#scripts/notify/telegram-notify'
-import { detached_launch } from '#scripts/run/detached-launch'
+import { detached_launch, type LaunchArgv } from '#scripts/run/detached-launch'
 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 { run_ending } from '#scripts/run/run-ending'
@@ -197,7 +197,7 @@ function existing_dispatch(request: StartRequest): DispatchOutcome | undefined {
 	return dispatched_of(request, active.pid, [])
 }
 
-function launch_argv(request: StartRequest, nonce: string | undefined): AgentArgv {
+function launch_argv(request: StartRequest, nonce: string | undefined): LaunchArgv {
 	if (request.profile.provider !== 'openai') return request.argv
 	if (nonce === undefined) throw new Error('OpenAI supervisor nonce is missing')
 
@@ -404,7 +404,7 @@ function log_sentence(outcome: Dispatched, issue: string): string {
 		return ` Its output is NOT being kept — ${outcome.notes.join(NOTE_SEPARATOR)} — so ${outcome.log_path} will not grow and the process trace is the only answer: ${poll}.`
 	}
 
-	return ` It writes to ${outcome.log_path}. To poll it, ${poll}.`
+	return ` It writes to ${outcome.log_path}. Wait on it with \`pnpm josh lane:await ${issue} --owner "$PPID"\` in the background and end the turn; once that output falls silent, ${poll}.`
 }
 
 // Whether this dispatch resumed the disconnected child's session or started fresh — the report the

package/scripts/lane/lane-guard-policy.ts

@@ -45,27 +45,27 @@ interface LaneGuardEntry {
 const LANE_GUARD_POLICY: ReadonlyArray<LaneGuardEntry> = [
 	{
 		id: 'investigation',
-		mode_in_lane_child: 'notice',
+		mode_in_lane_child: 'refuse',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138), which is why it was `off` from #2138 to #2382. The exemption reason — "the child is itself the delegated unit, so it cannot dispatch a sub-unit to read its own edit targets" — did not hold in measurement: kit#2382 re-measured the six lane children after #2347 (#2366 #2370 #2371 #2372 #2374 #2375) and every one dispatched sub-agents (10 launches, 2 of them investigation fan-outs) and read 4–17 files it never edited, all six over the threshold of 3. So the reading the guard exists to send out was there to send. It takes `notice`, not `off`: the child is nudged to delegate rather than killed, on the `additionalContext` path batching and duplicate-read already use, and the notice names the concrete unedited files this run read (the #2276 precedent) rather than the generic "delegate" #2164 → #2178 measured not to move the number. The density is a genuine experiment — re-measured on the next backlogrun, and a notice that still does not move it is redesigned rather than kept',
+			'the notice was measured not to move the reading — 52% of lane cost stayed in main-line exploration — and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line',
 	},
 	{
 		id: 'batching',
 		mode_in_lane_child: 'off',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138); kit#2164 replaced it with a notice, kit#2178 took that notice off after it did not move the density, and kit#2276 restored it — naming the concrete recent calls and recurring every single-call turn — as a genuine experiment to be redesigned rather than kept if the next backlogrun still missed 1.40. kit#2405 is that re-measurement, and it cuts the notice off (`off`). `josh time:density` read 1.13 calls per round trip over the ten most recent lanes (1.04 in the Issue’s per-message frame), short of the 1.40 target as every advisory attempt before it was (kit#1304/#1329/#1337/#1390/#2164/#2276). The cause is structural rather than wording: a `PreToolUse` hook cannot see the turn it is in — a turn’s later `tool_use` lines arrive 1.4–15s after its first — so it judges only closed turns, and a notice at turn close still asks for the parallel `tool_use` blocks the model resists. The one lever measured to move the density is a composite command the model emits in a single call (`read:files`/`edit:files`, kit#2202/#2311), which needs no notice. So per the issue’s instruction to discontinue advisory means when the target is missed, the notice is cut off rather than rewritten a seventh time; the density stays readable through `josh time:density`',
+			'a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`',
 	},
 	{
 		id: 'duplicate-read',
 		mode_in_lane_child: 'notice',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138), and the unchanged re-reads the guard catches are measured in lane children above all (kit#2298 baseline: 8.0 per lane run) — so silencing it there (`off`) would neuter it exactly where the count lives. It takes `notice` instead: the child is nudged to scroll up to the earlier read rather than killed. The mode is a genuine experiment, as the batching notice is — a notice that does not reduce the duplicate reads on the next backlogrun is redesigned rather than kept',
+			'a refusal ends a child turn, yet unchanged re-reads are measured in lane children above all, so the child is nudged to scroll up to the earlier read by a notice rather than killed',
 	},
 	{
 		id: 'rule',
 		mode_in_lane_child: 'refuse',
 		because:
-			"it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules a child must still obey (`shell-body`, `piped-verification`); a blanket suppression would disarm exactly the guards written for the child. `implementation-cut` (joshuafolkken/kit#2310) needs `refuse` for the same reason the pre-gate cut does — kit#1864 and kit#2310 both measured a cut carried as prose firing 0 times, so a notice, being prose in front of the run, would drop enforcement without a procedural replacement. The pre-gate-cut refusal does collateral a sibling call batched in the same turn — a `PreToolUse` deny cancels the turn's other parallel calls, which is the harness behavior kit#2177 measured on #2160 (gate refused, its batched `review:brief` cancelled) — and that collateral is not avoidable at the guard level. `notice` was considered for the pre-gate-cut point and rejected: kit#1864 measured the cut taken 0 times while it was carried as prose, and a notice is prose in front of the run (kit#2178 measured a lane-child notice not moving the number), so a notice would drop enforcement without a procedural replacement. kit#2177 supplies that replacement in the procedure instead — the chain orders the cut before the gate, so the cut is issued on its own (its `cut` verdict ends the turn, batching with nothing) and the gate runs in the fresh process where the carried cut keeps this guard silent; the refusal therefore stays `refuse` as insurance and the collateral is gone from the default path rather than from the guard",
+			'it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire',
 	},
 ]
 

package/scripts/lane/lane-handoff.ts

@@ -24,6 +24,13 @@ function is_ship_running(issue: string, directory: string): boolean {
 	)
 }
 
+// When the detached ship for `issue` that is still live was launched, or `undefined` where none is.
+function ship_running_since(issue: string, directory: string): number | undefined {
+	const repository = git_common_directory.repository(directory)
+
+	return repository === undefined ? undefined : run_ship_detach.running_since(repository, issue)
+}
+
 // This session is the dispatched lane child for `directory` and its own ship is running.
 function is_handed_off(directory: string, source: MarkerSource = process.env): boolean {
 	const issue = lane_child_marker.marked_issue(source)
@@ -33,6 +40,6 @@ function is_handed_off(directory: string, source: MarkerSource = process.env): b
 	return is_ship_running(issue, directory)
 }
 
-const lane_handoff = { is_handed_off, is_ship_running }
+const lane_handoff = { is_handed_off, is_ship_running, ship_running_since }
 
 export { lane_handoff }

package/scripts/lane/lane-install.ts

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { core_budget } from '#scripts/gate/core-budget'
 import { buffered_process } from '#scripts/lib/buffered-process'
 import { INSTALL_TIMEOUT_MS } from '#scripts/lib/timeouts'
 
@@ -68,10 +69,17 @@ function has_manifest(directory: string): boolean {
 async function install_dependencies(directory: string): Promise<InstallResult> {
 	if (!has_manifest(directory)) return { is_installed: true, output: NO_MANIFEST_OUTPUT }
 
-	const result = await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
-		cwd: directory,
-		timeout_ms: INSTALL_TIMEOUT_MS,
-	})
+	// The install claims its place in the core budget (joshuafolkken/kit#3944): a batch opens its lanes
+	// together, and each install ran beside the other lanes' gates off the ledger.
+	const result = await core_budget.with_command_reservation(
+		core_budget.CORE_WEIGHTS.install,
+		async () =>
+			await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
+				cwd: directory,
+				timeout_ms: INSTALL_TIMEOUT_MS,
+			}),
+		{ memory_mb: core_budget.MEMORY_MB.install, command: 'lane install' },
+	)
 
 	return { is_installed: !buffered_process.is_process_failed(result), output: result.output }
 }