@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/scripts/run/ship/run-ship-stop-context.ts

@@ -0,0 +1,206 @@
+import { stripVTControlCharacters } from 'node:util'
+import { agent_role_profile } from '#scripts/agent/agent-role-profile'
+import { changed_paths } from '#scripts/git/changed-paths'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { z } from 'zod'
+import { run_ship_next } from './run-ship-next'
+import { run_ship_probe } from './run-ship-probe'
+
+// What a relaunched lane child needs in front of it to fix a stopped ship: the tail of the failed
+// stage's output — a red check, or the High/Medium findings a review stage reports — and the branch's
+// changed files. Without them the resumed session opened `josh ship --log` and `git diff` itself before
+// doing anything (joshuafolkken/kit#3923).
+//
+// **Both are bounded**, so a long gate log never becomes the whole prompt. The tail is kept because a
+// check reports its verdict last; the lines left out go to a file whose path and line range the prompt
+// names, so nothing is lost and the session reads only the range it needs.
+
+const EXCERPT_LINE_LIMIT = 40
+const EXCERPT_LINE_WIDTH = 240
+const CHANGED_PATH_LIMIT = 30
+const OUTPUT_PREFIX = 'josh-ship-stop-'
+const OUTPUT_SUFFIX = '.log'
+const KEY_SEPARATOR = '-'
+const LINE_BREAK = '\n'
+const CARRIAGE_RETURN = '\r'
+
+const omitted_schema = z
+	.object({ path: z.string().optional(), last_line: z.number().int() })
+	.strict()
+const stop_context_schema = z
+	.object({
+		excerpt: z.array(z.string()).readonly(),
+		omitted: omitted_schema.optional(),
+		changed: z.array(z.string()).readonly().optional(),
+		more_changed: z.number().int(),
+	})
+	.strict()
+
+type StopContext = z.infer<typeof stop_context_schema>
+type Omitted = z.infer<typeof omitted_schema>
+
+// A spinner redraws its line with a carriage return, so only the frame after the last one is what the
+// terminal showed; a CRLF line ends in one and keeps its whole text.
+function shown_frame(line: string): string {
+	return line.trimEnd().split(CARRIAGE_RETURN).at(-1) ?? ''
+}
+
+function output_lines(output: string): Array<string> {
+	return stripVTControlCharacters(output)
+		.trimEnd()
+		.split(LINE_BREAK)
+		.map((line) => agent_role_profile.printable(shown_frame(line)))
+}
+
+// The full output is kept beside the ship log, keyed the same way, so the prompt's line range points at
+// text that reads exactly as the excerpt was cut from.
+async function keep_full_output(issue: string, output: string): Promise<string | undefined> {
+	const repository = await run_ship_probe.repository_directory()
+
+	if (repository === undefined) return undefined
+
+	const target = stamp_file.stamp_path(
+		`${OUTPUT_PREFIX}${issue}${KEY_SEPARATOR}`,
+		repository,
+		OUTPUT_SUFFIX,
+	)
+
+	try {
+		return stamp_file.replace_text_stamp(target, output)
+	} catch {
+		return undefined
+	}
+}
+
+// A full output that could not be kept still reports the cut, with no path: the prompt then points at
+// the stopped report, which holds the same lines.
+async function omitted_range(issue: string, lines: ReadonlyArray<string>): Promise<Omitted> {
+	const path = await keep_full_output(issue, lines.join(LINE_BREAK))
+	const last_line = lines.length - EXCERPT_LINE_LIMIT
+
+	return path === undefined ? { last_line } : { path, last_line }
+}
+
+// A line is cut to a width, so one minified or wrapped line cannot spend the prompt's whole budget.
+function clipped(lines: ReadonlyArray<string>): Array<string> {
+	return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH))
+}
+
+async function excerpt_of(
+	issue: string,
+	output: string,
+): Promise<Pick<StopContext, 'excerpt' | 'omitted'>> {
+	const lines = output.trim() === '' ? [] : output_lines(output)
+
+	if (lines.length <= EXCERPT_LINE_LIMIT) return { excerpt: clipped(lines) }
+
+	return {
+		excerpt: clipped(lines.slice(-EXCERPT_LINE_LIMIT)),
+		omitted: await omitted_range(issue, lines),
+	}
+}
+
+// A git that cannot answer leaves the list out rather than costing the relaunch — never empty, which
+// would read as a branch with no changes.
+async function read_paths(): Promise<Array<string> | undefined> {
+	try {
+		return await changed_paths.read_changed_paths(false)
+	} catch {
+		return undefined
+	}
+}
+
+async function changed_of(): Promise<Pick<StopContext, 'changed' | 'more_changed'>> {
+	const paths = await read_paths()
+
+	if (paths === undefined) return { more_changed: 0 }
+
+	return {
+		changed: paths.slice(0, CHANGED_PATH_LIMIT),
+		more_changed: Math.max(0, paths.length - CHANGED_PATH_LIMIT),
+	}
+}
+
+async function build(issue: string, output: string): Promise<StopContext> {
+	return { ...(await excerpt_of(issue, output)), ...(await changed_of()) }
+}
+
+function has_excerpt(context: StopContext | undefined): boolean {
+	return context !== undefined && context.excerpt.length > 0
+}
+
+function excerpt_heading(issue: string, omitted: Omitted | undefined, shown: number): string {
+	if (omitted === undefined) return 'The failed stage output:'
+
+	const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue}\`)`
+	const range = `lines 1-${String(omitted.last_line)} are in ${source}`
+
+	return `The failed stage output (its last ${String(shown)} lines; ${range}):`
+}
+
+// The head lines a budget leaves out join the range the heading names; the file, when one was kept,
+// still holds every line.
+function with_dropped(omitted: Omitted | undefined, dropped: number): Omitted | undefined {
+	if (dropped === 0) return omitted
+
+	return { ...omitted, last_line: (omitted?.last_line ?? 0) + dropped }
+}
+
+function excerpt_block(
+	issue: string,
+	context: StopContext,
+	changed: string,
+	dropped: number,
+): string {
+	const shown = context.excerpt.slice(dropped)
+	const heading = excerpt_heading(issue, with_dropped(context.omitted, dropped), shown.length)
+
+	return [heading, ...shown, changed].join(LINE_BREAK)
+}
+
+function changed_text(context: StopContext): string {
+	if (context.changed === undefined) return 'The changed files could not be read from git.'
+
+	if (context.changed.length === 0) return 'No files changed against the default branch.'
+
+	const more = context.more_changed > 0 ? ` (and ${String(context.more_changed)} more)` : ''
+
+	return `Changed files on the branch: ${context.changed.join(', ')}${more}.`
+}
+
+// The block the ship-stop prompt carries between the next command and the closing invocation.
+//
+// **It fits the `budget` the prompt leaves it** — the prompt is one argv element, refused past
+// `MAX_VALUE_LENGTH` (joshuafolkken/kit#3964) — by dropping the excerpt's head first, since a check
+// reports its verdict last; the tail line always stays.
+function describe(
+	issue: string,
+	context: StopContext,
+	budget: number = agent_role_profile.MAX_VALUE_LENGTH,
+): string {
+	const changed = changed_text(context)
+
+	if (!has_excerpt(context)) return changed
+
+	let dropped = 0
+	let block = excerpt_block(issue, context, changed, dropped)
+
+	while (block.length > budget && dropped < context.excerpt.length - 1) {
+		dropped += 1
+		block = excerpt_block(issue, context, changed, dropped)
+	}
+
+	return block
+}
+
+const run_ship_stop_context = {
+	CHANGED_PATH_LIMIT,
+	EXCERPT_LINE_LIMIT,
+	build,
+	describe,
+	has_excerpt,
+	stop_context_schema,
+}
+
+export type { StopContext }
+export { run_ship_stop_context }

package/scripts/run/ship/run-ship-sync.ts

@@ -4,6 +4,7 @@ import { git_command } from '#scripts/git/git-command'
 import { main_merge, type MergeOutcome } from '#scripts/git/main-merge'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { error_text } from '#scripts/lib/error-message'
+import { run_ship_overlap } from './run-ship-overlap'
 import { run_ship_scoped } from './run-ship-scoped'
 
 // `josh ship` keeps the branch current with the default branch itself: a default branch that moves
@@ -11,9 +12,9 @@ import { run_ship_scoped } from './run-ship-scoped'
 // merging the default branch again usually resolves it.
 //
 // So the merge happens mechanically: once before the commit (`sync_stage`), and once when
-// the followup fails on a pull request GitHub reports `DIRTY` (`followup_stage`). Only a merge git
-// itself cannot finish stops the ship, and it stops as `conflict`, naming the unmerged paths so the
-// resumed session goes straight to them.
+// the followup fails on a pull request GitHub reports `DIRTY` (`followup_stage`). A conflict only on
+// generated files is regenerated by the merge itself (`main-merge-regenerate.ts`); any other conflict
+// stops the ship as `conflict`, naming the unmerged paths so the resumed session goes straight to them.
 
 const should_forward_stderr = true
 const SUCCESS_EXIT_CODE = 0
@@ -66,12 +67,19 @@ function sync_note(outcome: Exclude<MergeOutcome, { kind: 'conflict' }>): string
 // touches, and once that work is committed the followup merges again on a clean tree. A merge that changed
 // the tree is checked by the gate stage that follows, so the commit never carries
 // an unchecked merge and the gate's record names the merge base the push carries.
-async function sync_stage(): Promise<StepResult> {
+//
+// The merge waits first for any lane whose open pull request changes the same paths
+// (`run-ship-overlap.ts`), so it brings that pull request in before the gate rather than meeting it
+// as `DIRTY` after CI.
+async function sync_stage(issue: string): Promise<StepResult> {
+	const waited = run_ship_overlap.note(await run_ship_overlap.await_overlap(issue))
 	const outcome = await merge_outcome()
 
-	if (outcome.kind === 'conflict') return conflict_result(outcome.files, '')
+	if (outcome.kind === 'conflict') return conflict_result(outcome.files, waited)
+
+	const out = [waited, sync_note(outcome)].filter((line) => line !== '').join('\n')
 
-	return { code: SUCCESS_EXIT_CODE, out: sync_note(outcome) }
+	return { code: SUCCESS_EXIT_CODE, out }
 }
 
 // Any read that fails answers "not conflicting": the followup failure then stands as it was.

package/scripts/test/test-e2e-guard.ts

@@ -2,9 +2,13 @@
 import { existsSync, globSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { environment_flags } from '@joshuafolkken/kit/env'
+import { core_budget } from '#scripts/gate/core-budget'
 import { execa } from 'execa'
 
 const PNPM = 'pnpm'
+// `--workers`, `--workers=<n>` and Playwright's `-j` short form.
+const WORKER_FLAGS = /^(?:--workers(?:=|$)|-j)/u
 const FAIL_EXIT_CODE = 1
 const ARGV_START = 2
 const PLAYWRIGHT_PACKAGE = path.join('node_modules', '@playwright', 'test')
@@ -45,15 +49,36 @@ function has_e2e_tests(project_directory: string): boolean {
 	return matches.length > 0
 }
 
+// **A local run's worker count is the weight it reserved** (joshuafolkken/kit#3944). Playwright's own
+// default is half the cores, which no ledger entry stood for; CI keeps its config's count, and a
+// count the caller names wins.
+function playwright_arguments(extra_arguments: ReadonlyArray<string>): ReadonlyArray<string> {
+	const is_count_named = extra_arguments.some((argument) => WORKER_FLAGS.test(argument))
+
+	if (is_count_named || environment_flags.is_ci_enabled(process.env['CI'])) return extra_arguments
+
+	return [`--workers=${String(core_budget.CORE_WEIGHTS.e2e)}`, ...extra_arguments]
+}
+
 async function run_playwright(extra_arguments: ReadonlyArray<string>): Promise<number> {
-	const result = await execa(PNPM, ['exec', 'playwright', 'test', ...extra_arguments], {
-		stdio: 'inherit',
-		reject: false,
-	})
+	const result = await execa(
+		PNPM,
+		['exec', 'playwright', 'test', ...playwright_arguments(extra_arguments)],
+		{ stdio: 'inherit', reject: false },
+	)
 
 	return result.exitCode ?? FAIL_EXIT_CODE
 }
 
+// Only a run reserves: a skip starts nothing, and a claim there could wait out a full ledger for it.
+async function run_reserved_playwright(extra_arguments: ReadonlyArray<string>): Promise<number> {
+	return await core_budget.with_command_reservation(
+		core_budget.CORE_WEIGHTS.e2e,
+		async () => await run_playwright(extra_arguments),
+		{ command: 'test:e2e' },
+	)
+}
+
 async function run_guarded_e2e(
 	project_directory: string,
 	extra_arguments: ReadonlyArray<string>,
@@ -61,7 +86,7 @@ async function run_guarded_e2e(
 	const is_installed = is_playwright_installed(project_directory)
 	const has_tests = has_e2e_tests(project_directory)
 	const action = resolve_guard_action(is_installed, has_tests)
-	if (action === 'run') return await run_playwright(extra_arguments)
+	if (action === 'run') return await run_reserved_playwright(extra_arguments)
 
 	console.info(`josh test:e2e: ${SKIP_REASONS[action]} — skipping Playwright e2e.`)
 

package/scripts/test/test-unit-guard.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env tsx
 import { existsSync, globSync } from 'node:fs'
+import { availableParallelism } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { PROJECT_ENVIRONMENT_KEYS } from '#ports'
+import { free_cores } from '#scripts/gate/free-cores'
 import { project_checks } from '#scripts/gate/project-checks'
 import { execa } from 'execa'
 import { project_test_script, type ProjectScriptState } from './project-test-script'
@@ -175,11 +177,24 @@ function isolated_unit_environment(
 // Reading the share first and claiming afterwards leaves a window in which two hooks firing together
 // both count "alone" and both run uncapped. Inside the marker the number is identical — this run's own
 // record is now on disk and `is_nested_run` therefore contributes nothing — and the window is gone.
+//
+// **The machine is read only when no count was typed.** The reading waits out a sample window, and a
+// caller's `--maxWorkers` — the gate's cap among them, already bounded by the same reading — wins
+// whatever it says.
+async function vitest_share(vitest_arguments: ReadonlyArray<string>): Promise<number | undefined> {
+	if (unit_worker_share.has_worker_flag(vitest_arguments)) return undefined
+
+	const available_cores = availableParallelism()
+	const free = await free_cores.read({ available_cores })
+
+	return unit_worker_share.current_share(available_cores, unit_worker_share.live_run_count(), free)
+}
+
 async function run_vitest(vitest_arguments: ReadonlyArray<string>): Promise<number> {
 	return await unit_worker_share.with_run_marker(async () => {
 		const sized = unit_worker_share.worker_arguments(
 			vitest_arguments,
-			unit_worker_share.current_share(),
+			await vitest_share(vitest_arguments),
 		)
 		const result = await execa(PNPM, ['exec', 'vitest', ...vitest_arguments, ...sized], {
 			env: isolated_unit_environment(),

package/scripts/test/unit-worker-share.ts

@@ -153,6 +153,22 @@ function resolve_unit_workers(available_cores: number, runs: number): number | u
 	return Math.max(MIN_WORKERS, Math.floor(available_cores / runs))
 }
 
+// **The run count divides the machine; the free cores bound what that division hands out.** The
+// share counts only unit runs, so load from outside the core budget's ledger — Claude sessions, other
+// tools — went unseen: 22 of 38 ledger samples at a load average of 20 or more had vitest as their
+// heaviest process, one at 381% over 30 processes. `free_cores` is `free-cores.ts`'s reading, the
+// cores less that outside load. `undefined` — a CI runner, a CPU quota — and a reading at or above
+// the ceiling both leave `workers` as it was, so an unread or quiet machine changes nothing.
+function cap_to_free(
+	workers: number | undefined,
+	free_cores: number | undefined,
+	available_cores: number,
+): number | undefined {
+	if (free_cores === undefined || free_cores >= (workers ?? available_cores)) return workers
+
+	return Math.max(MIN_WORKERS, Math.floor(free_cores))
+}
+
 // The share this run may take, read from the machine. Separate from `resolve_unit_workers` so that
 // one stays a pure function of two numbers and every test of it can pass them.
 //
@@ -163,10 +179,12 @@ function resolve_unit_workers(available_cores: number, runs: number): number | u
 function current_share(
 	available_cores: number = availableParallelism(),
 	live_runs: number = live_run_count(),
+	free_cores?: number,
 ): number | undefined {
 	const own_run = is_nested_run() ? 0 : SOLO_RUNS
+	const share = resolve_unit_workers(available_cores, live_runs + own_run)
 
-	return resolve_unit_workers(available_cores, live_runs + own_run)
+	return cap_to_free(share, free_cores, available_cores)
 }
 
 function is_worker_flag(argument: string): boolean {
@@ -182,13 +200,15 @@ function is_worker_flag(argument: string): boolean {
 // would make this function's own answer depend on what happened to be running while it was asked, and
 // `f(args, undefined)` takes the default rather than the value — so the case that matters most, "this
 // run is alone", would be the one case no test could express.
+function has_worker_flag(vitest_arguments: ReadonlyArray<string>): boolean {
+	return vitest_arguments.some((argument) => is_worker_flag(argument))
+}
+
 function worker_arguments(
 	vitest_arguments: ReadonlyArray<string>,
 	share: number | undefined,
 ): Array<string> {
-	if (share === undefined || vitest_arguments.some((argument) => is_worker_flag(argument))) {
-		return []
-	}
+	if (share === undefined || has_worker_flag(vitest_arguments)) return []
 
 	return [`${WORKER_FLAG}=${String(share)}`]
 }
@@ -230,7 +250,9 @@ const unit_worker_share = {
 	NESTED_VALUE,
 	RUN_PREFIX,
 	SOLO_RUNS,
+	cap_to_free,
 	current_share,
+	has_worker_flag,
 	is_nested_run,
 	live_run_count,
 	marker_path,

package/scripts/time-runtime/time-shell.ts

@@ -32,8 +32,9 @@ const SEGMENT_PATTERN = /&&|\|\||;|\|/u
 // last, while `||` keeps the first command's and runs the second only when it failed. `|&` is a pipe
 // and is cut here, its `&` left in the fragment that follows.
 const PIPE_PATTERN = /(?<!\|)\|(?!\|)/u
-// What `SEGMENT_PATTERN` cuts on minus the pipe, for reading *inside* one pipe segment.
-const CHAIN_PATTERN = /&&|\|\||;/u
+// What `SEGMENT_PATTERN` cuts on minus the pipe, for reading *inside* one pipe segment — plus the
+// newline, which ends a command as `;` does, so a line typed before the piped check is not read as it.
+const CHAIN_PATTERN = /&&|\|\||;|\n/u
 // A quoted span is text, not shell syntax, and it is removed before the pipe reading below. This
 // repository's issue bodies, comment bodies and commit messages quote command chains constantly, so
 // `--body "cd x && pnpm josh gate | tail"` is a `gh` call and nothing else — a reader that split its
@@ -299,8 +300,8 @@ function drop_redirections(words: ReadonlyArray<string>): Array<string> {
 // **The match's own text is what is sliced off, not a fixed word count.** The prefix is two words in
 // `josh lint`, three in `pnpm josh lint` and four in `pnpm exec josh lint`, so counting words would
 // leave `josh` itself in the argument list for one of the three spellings.
-function josh_arguments(command: string): Array<string> {
-	const text = command_words(command_segment(command)).join(' ')
+function josh_arguments_of_segment(segment: string): Array<string> {
+	const text = command_words(segment).join(' ')
 	const match = JOSH_PATTERN.exec(text)
 
 	if (match === null) return []
@@ -313,6 +314,29 @@ function josh_arguments(command: string): Array<string> {
 	return drop_redirections(words)
 }
 
+function josh_arguments(command: string): Array<string> {
+	return josh_arguments_of_segment(command_segment(command))
+}
+
+// The josh subcommand one segment runs plus every argument it passes, redirections dropped, or `''`
+// for a segment that runs none. **Flags are kept**: which of them ask nothing new (`run:board --chat`)
+// and which turn a read into a write (`run:carry --cut`) is the reader's rule, not this one's.
+function josh_signature_of_segment(segment: string): string {
+	const name = josh_command_of_segment(segment)
+
+	if (name === '') return ''
+
+	return [name, ...josh_arguments_of_segment(segment)].join(' ')
+}
+
+// Every segment's signature, read over the same unquoted chain `josh_commands_of` walks.
+function josh_signatures_of(command: string): Array<string> {
+	return unquoted(command)
+		.split(SEGMENT_PATTERN)
+		.map((segment) => josh_signature_of_segment(segment))
+		.filter((signature) => signature !== '')
+}
+
 const time_shell = {
 	JOSH_PREFIX,
 	bash_command,
@@ -323,6 +347,7 @@ const time_shell = {
 	josh_arguments,
 	josh_command_of,
 	josh_commands_of,
+	josh_signatures_of,
 	leading_word,
 	unquoted,
 }

package/scripts/time-runtime/time-spans.ts

@@ -334,6 +334,7 @@ function to_spans(events: ReadonlyArray<TimelineEvent>, finished: FinishedAt): A
 		label: event.label,
 		josh_command: event.josh_command,
 		josh_commands: event.josh_commands,
+		josh_signatures: event.josh_signatures,
 		check_key: event.check_key,
 		marker: event.marker,
 		is_bundleable: event.is_bundleable,

package/scripts/time-runtime/time-tool-call.ts

@@ -55,6 +55,9 @@ interface ToolCall {
 	// A chained `pnpm josh lint:related && pnpm josh test:related` carries both; the count tables expand
 	// it so the ones `josh_command` drops are still counted.
 	josh_commands: ReadonlyArray<string>
+	// Each of those with the operands it named, flags dropped — what tells `lane:output 1` from
+	// `lane:output 2` once the span has kept no command string. `run-poll-hook.ts` reads it.
+	josh_signatures: ReadonlyArray<string>
 	check_key: string
 	marker: PhaseMarker
 	is_bundleable: boolean
@@ -83,6 +86,7 @@ const NO_CALL: ToolCall = {
 	label: '',
 	josh_command: '',
 	josh_commands: [],
+	josh_signatures: [],
 	check_key: time_single_check.NO_CHECK,
 	marker: time_markers.NO_MARKER,
 	message_id: NO_MESSAGE_ID,
@@ -95,6 +99,7 @@ const UNKNOWN_CALL: ToolCall = {
 	label: UNKNOWN_TOOL,
 	josh_command: '',
 	josh_commands: [],
+	josh_signatures: [],
 	check_key: time_single_check.NO_CHECK,
 	marker: time_markers.NO_MARKER,
 	message_id: NO_MESSAGE_ID,
@@ -111,6 +116,7 @@ function non_bash_call(name: string, input: unknown, message_id: string): ToolCa
 		label: name,
 		josh_command: '',
 		josh_commands: [],
+		josh_signatures: [],
 		check_key: time_single_check.NO_CHECK,
 		marker: time_markers.tool_marker(name, input),
 		message_id,
@@ -132,6 +138,7 @@ function bash_call(input: unknown, message_id: string): ToolCall {
 		label: time_shell.bash_label(command),
 		josh_command,
 		josh_commands: time_shell.josh_commands_of(command),
+		josh_signatures: time_shell.josh_signatures_of(command),
 		check_key: time_single_check.check_key(josh_command, command),
 		marker: time_markers.bash_marker(command),
 		message_id,

package/templates/gitignore

@@ -43,13 +43,17 @@ project.inlang/cache/
 *storybook.log
 storybook-static
 
-# Verification gate caches (josh lint / josh check / josh cspell:dot), plus the edit hook's own
-# eslint cache (josh format:edited), which is kept apart from the gate's on purpose
+# Verification gate caches (josh lint / josh check / josh cspell:dot), plus the edit hook's, the
+# scoped lint's and the pre-commit hook's own, which are kept apart from the gate's on purpose
 .eslintcache
 .eslintcache.edit
 .eslintcache.related
+.eslintcache.commit
 .tsbuildinfo
 .cspellcache
+.cspellcache.commit
+.prettiercache
+.prettiercache.related
 
 # Bundle analysis
 stats-client.html

package/dist/hooks/chunk-K4LMBQC2.js

@@ -1,68 +0,0 @@
-import {
-  investigation_reads
-} from "./chunk-H5HVWYXK.js";
-import {
-  lane_guard_policy
-} from "./chunk-SHGPANFB.js";
-import {
-  hook_decision
-} from "./chunk-J47HU5H5.js";
-
-// scripts/delegation/investigation-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_INVESTIGATION_GUARD";
-var STAMP_PREFIX = "josh-investigation-guard-";
-var NOTICE_STAMP_PREFIX = "josh-investigation-guard-notice-";
-function investigation_mode() {
-  return lane_guard_policy.mode_here("investigation");
-}
-function should_block(tail, call, refused_at_ms, run) {
-  if (investigation_mode() !== "refuse") return false;
-  return investigation_reads.should_block(tail, call, refused_at_ms, run);
-}
-function should_notify(tail, call, notified_at_ms, run) {
-  if (investigation_mode() !== "notice") return false;
-  return investigation_reads.should_block(tail, call, notified_at_ms, run);
-}
-var NOTICE = `\u{1F4A1} investigation: files read and not edited, or search turns, since the last delegated unit reached the threshold; the read proceeds. Run \`pnpm josh delegate investigation\`, then dispatch the \`${investigation_reads.INVESTIGATOR_AGENT}\` agent (\`kit:${investigation_reads.INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text. Keep main-line reads to files you will edit.`;
-function notice_text(_call, tail) {
-  const pending = investigation_reads.tally_of(tail).pending.map((absolute) => investigation_reads.repository_relative(absolute));
-  return pending.length === 0 ? NOTICE : `${NOTICE} Read and not edited so far: ${pending.join(" ")}.`;
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate: investigation_reads.is_refusable_call,
-  should_block,
-  reason: investigation_reads.REASON,
-  // The lane-child notice fires where the refusal is withheld, on a record of its own so it
-  // never spends the refusal's stamp.
-  notify: {
-    prefix: NOTICE_STAMP_PREFIX,
-    should_notify,
-    text: notice_text
-  }
-});
-var investigation_refusal = GUARD.refusal;
-var investigation_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var investigation_notice_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("investigation:guard");
-  else hook_decision.write_outcome(await text(process.stdin), investigation_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  NOTICE,
-  investigation_refusal,
-  investigation_outcome,
-  is_enabled,
-  refusal_path,
-  investigation_notice_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};