@joshuafolkken/kit 1.957.0 → 1.972.0

package/scripts/hooks/stop-guard.ts

@@ -78,6 +78,7 @@ async function build_context(
 		headless_refusals: stop_rules.count_headless_refusals(tail),
 		lane_child: lane_child_marker.is_child_of(process.cwd()),
 		background_pending: lane_background.pending_background_ids(tail).length > 0,
+		agent_pending: lane_background.pending_agent_ids(tail).length > 0,
 		session_lang: session_lang(),
 	}
 }

package/scripts/init/init-install.ts

@@ -0,0 +1,64 @@
+import { execaSync } from 'execa'
+
+interface InstallStep {
+	label: string
+	command: string
+	args: ReadonlyArray<string>
+}
+
+interface InstallRequest {
+	is_install: boolean
+	rest: ReadonlyArray<string>
+}
+
+const NO_INSTALL_FLAG = '--no-install'
+const INSTALL_STEP: InstallStep = { label: 'pnpm install', command: 'pnpm', args: ['install'] }
+const FORMAT_STEP: InstallStep = {
+	label: 'pnpm josh format',
+	command: 'pnpm',
+	args: ['exec', 'josh', 'format'],
+}
+const INSTALL_FAILURE = [
+	`${INSTALL_STEP.label} failed — fix the cause above,`,
+	`then run it manually: ${INSTALL_STEP.label} && ${FORMAT_STEP.label}`,
+].join(' ')
+const FORMAT_WARNING = [
+	`  ⚠ ${FORMAT_STEP.label} left problems it could not fix in the project's own files —`,
+	`the setup itself succeeded; fix them, then run: ${FORMAT_STEP.label}`,
+].join(' ')
+
+// The flag is peeled off before the `--profile` pair is parsed, so the profile parser stays the one
+// `josh start` shares.
+function split_install_flag(args: ReadonlyArray<string>): InstallRequest {
+	return {
+		is_install: !args.includes(NO_INSTALL_FLAG),
+		rest: args.filter((argument) => argument !== NO_INSTALL_FLAG),
+	}
+}
+
+function did_step_succeed(step: InstallStep, project_root: string): boolean {
+	console.info(`\n$ ${step.label}`)
+	const result = execaSync(step.command, step.args, {
+		cwd: project_root,
+		stdio: 'inherit',
+		reject: false,
+	})
+
+	return result.exitCode === 0
+}
+
+// Returns the failure to report, or undefined once the install passed. A failed install stops
+// there: `josh format` runs prettier and the kit itself, both of which the install provides. A failed
+// format does not fail `init` — in a node project it also runs `eslint --fix`, which exits non-zero on
+// the project's own unfixable errors, and those are the project's result, not the setup's (the
+// reason `josh gate` is left out of `init` too).
+function run_post_init_steps(project_root: string): string | undefined {
+	console.info('\nDependencies:')
+	if (!did_step_succeed(INSTALL_STEP, project_root)) return INSTALL_FAILURE
+	if (!did_step_succeed(FORMAT_STEP, project_root)) console.warn(FORMAT_WARNING)
+
+	return undefined
+}
+
+const init_install = { NO_INSTALL_FLAG, split_install_flag, run_post_init_steps }
+export { init_install }

package/scripts/init/init.ts

@@ -15,6 +15,7 @@ import { execaSync } from 'execa'
 import { z } from 'zod'
 import { init_actions, PRETTIER_CONFIG_JS, type FileAction } from './init-actions'
 import { init_ai_copy } from './init-ai-copy'
+import { init_install } from './init-install'
 import { init_logic } from './init-logic'
 import { PACKAGE_DIR, PROJECT_ROOT } from './init-paths'
 import { init_static } from './init-static'
@@ -28,6 +29,7 @@ const SAMPLE_INDENT_WIDTH = 4
 const ARGUMENT_START_INDEX = 2
 const SAMPLE_INDENT = ' '.repeat(SAMPLE_INDENT_WIDTH)
 const INSTALL_HINT = '→ run `pnpm install` to install what package.json lists'
+const INIT_USAGE = 'josh init [--profile static|node] [--no-install]'
 
 function write_new_file(action: FileAction, destination_path: string): void {
 	mkdirSync(path.dirname(destination_path), { recursive: true })
@@ -218,14 +220,10 @@ function merge_project_package_json(shape: ProjectShape): void {
 
 	writeFileSync(package_json_path, merged)
 	console.info(`  ✔ ${is_existing ? 'updated' : 'created'}   package.json`)
-	// `init` writes the manifest but installs nothing, so a tool it just listed is absent until the
-	// user installs it — and `josh lint` then fails on it rather than skipping it
-	// (joshuafolkken/kit#2709). Saying so here is what tells the user the next step.
-	console.info(`    ${INSTALL_HINT}`)
 }
 
-// A fresh project runs `init` before its first `pnpm install`, so lefthook — added to devDependencies
-// above — is not there yet; the `prepare` script installs the hooks once it is.
+// Under `--no-install` a fresh project has no lefthook yet — added to devDependencies above — so the
+// `prepare` script of the user's own `pnpm install` installs the hooks once it is.
 function install_lefthook(project_root: string = PROJECT_ROOT): void {
 	console.info('\nLefthook:')
 	const bin = resolve_local_bin(project_root, LEFTHOOK_BIN)
@@ -285,8 +283,6 @@ function run_ai_file_actions(shape: ProjectShape): void {
 	// resolved, so `gh repo view` runs once; the position is the pre-existing one.
 	const name_with_owner = init_ai_copy.run_ai_copies(shape)
 
-	if (shape.has_git && shape.profile === 'node') install_lefthook()
-
 	if (shape.has_github) report_repository_settings(name_with_owner)
 
 	if (shape.profile === 'node') plugin_install_hint_module.report_plugin_install_hint()
@@ -302,19 +298,50 @@ function initialize_project(shape: ProjectShape): void {
 
 	run_ai_file_actions(shape)
 	if (shape.profile === 'node') project_config.sync_project_config(PROJECT_ROOT)
-	console.info('\n✅ Done.\n')
+}
+
+// A tool `init` just listed is absent until the user installs it — and `josh lint` then fails on it
+// rather than skipping it (joshuafolkken/kit#2709). Saying so is what tells the user the next step.
+function report_manual_install(shape: ProjectShape): void {
+	console.info(`\nDependencies:\n  ${INSTALL_HINT}`)
+	if (shape.has_git && shape.profile === 'node') install_lefthook()
+}
+
+// The install runs the `prepare` script, which installs the git hooks. A failure is thrown rather
+// than printed, so `josh start` — which calls this entry point — stops before its first commit.
+function finish_dependencies(shape: ProjectShape, is_install: boolean): void {
+	if (!is_install) {
+		report_manual_install(shape)
+
+		return
+	}
+
+	const failure = init_install.run_post_init_steps(PROJECT_ROOT)
+	if (failure !== undefined) throw new Error(failure)
 }
 
 function main(args: ReadonlyArray<string> = []): void {
 	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return
-	const requested = project_profile.requested_profile(args)
+	const { is_install, rest } = init_install.split_install_flag(args)
+	const requested = project_profile.requested_profile(rest, INIT_USAGE)
 	const shape = project_profile.inspect_project(PROJECT_ROOT, requested)
 
 	initialize_project(shape)
+	finish_dependencies(shape, is_install)
+	console.info('\n✅ Done.\n')
+}
+
+function run_cli(args: ReadonlyArray<string>): void {
+	try {
+		main(args)
+	} catch (error) {
+		console.error(`\n✖ ${error instanceof Error ? error.message : String(error)}\n`)
+		process.exitCode = 1
+	}
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	main(process.argv.slice(ARGUMENT_START_INDEX))
+	run_cli(process.argv.slice(ARGUMENT_START_INDEX))
 }
 
 const init = {

package/scripts/issue/issue-closing-pr.ts

@@ -0,0 +1,93 @@
+import { git_closes_keyword } from '#scripts/git/git-closes-keyword'
+import { git_gh_api_path } from '#scripts/git/git-gh-api-path'
+import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_repo } from '#scripts/git/git-gh-repo'
+import { parse_json_object_safe } from '#scripts/git/parse-json-array'
+import { z } from 'zod'
+
+// **The merged pull request that closes an issue GitHub left open** (joshuafolkken/kit#2769). A
+// `backlogrun` child whose pull request merged while GitHub did not apply its `closes #N`
+// (joshuafolkken/kit#2770) came back OPEN, and `run:merge` counted it a failure and parked it — the
+// work had landed, only the issue's close had not.
+//
+// **A merged reference is not enough; the body must close this issue.** A merged pull request that
+// merely mentions the issue — a follow-up, a sibling in the same epic — cross-references it too, and
+// closing on that would close unfinished work. So the pull request counts only when its body's
+// `closes #N` names this issue, read through the one parser every `closes #N` reader shares.
+//
+// **Only references after the last reopen count.** A reopened issue whose earlier attempt merged
+// still carries that pull request's reference, and reading it would close the reopened work — the
+// same reason `issue-merged.ts` reads the last closed/reopened event.
+//
+// **Only a pull request in this repository counts.** A bare `closes #N` names an issue in the pull
+// request's own repository, so a merged pull request elsewhere whose `closes #N` carries the same
+// number closes a different issue — its cross-reference here is a mention, not a close.
+
+const LINE_SEPARATOR = '\n'
+// One compact JSON object per merged pull request that cross-references the issue, and a
+// `{"reopened":true}` marker per reopen, in timeline order.
+const TIMELINE_FILTER = [
+	'.[]',
+	'| if .event == "cross-referenced" and .source.issue.pull_request.merged_at != null',
+	'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // "")}',
+	'elif .event == "reopened" then {reopened: true}',
+	'else empty end',
+].join(' ')
+
+const reference_schema = z.object({ url: z.string(), repo: z.string(), body: z.string() })
+const reopen_schema = z.object({ reopened: z.literal(true) })
+const row_schema = z.union([reference_schema, reopen_schema])
+
+type MergedReference = z.infer<typeof reference_schema>
+type TimelineRow = z.infer<typeof row_schema>
+
+function is_reference(row: TimelineRow): row is MergedReference {
+	return 'url' in row
+}
+
+function parse_references(raw: string): Array<MergedReference> {
+	const rows = raw
+		.split(LINE_SEPARATOR)
+		.map((line) => parse_json_object_safe(line, row_schema))
+		.filter((row) => row !== undefined)
+	const last_reopen = rows.findLastIndex((row) => !is_reference(row))
+
+	return rows.slice(last_reopen + 1).filter((row) => is_reference(row))
+}
+
+function pick_closing_pr(
+	references: ReadonlyArray<MergedReference>,
+	issue: string,
+	repo: string,
+): string | undefined {
+	return references.find(
+		(reference) =>
+			reference.repo === repo &&
+			git_closes_keyword.parse_closes_issue_number(reference.body) === issue,
+	)?.url
+}
+
+// Every doubt falls to `undefined` — an unreadable timeline or repository name leaves the child
+// judged as it was, never closed on a guess.
+async function read_closing_pr(issue: string): Promise<string | undefined> {
+	try {
+		const [raw, repo] = await Promise.all([
+			git_gh_exec.exec_gh_api({
+				path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
+				should_paginate: true,
+				jq_filter: TIMELINE_FILTER,
+			}),
+			git_gh_repo.repo_get_name_with_owner(),
+		])
+
+		if (repo === undefined) return undefined
+
+		return pick_closing_pr(parse_references(raw), issue, repo)
+	} catch {
+		return undefined
+	}
+}
+
+const issue_closing_pr = { parse_references, pick_closing_pr, read_closing_pr }
+
+export { issue_closing_pr }

package/scripts/josh/__snapshots__/josh-command-map.test.ts.snap

@@ -449,10 +449,11 @@ exports[`COMMAND_MAP — reference metadata > keeps every canonical command and
       ],
     ],
     "init": [
-      "[--profile static|node]",
+      "[--profile static|node] [--no-install]",
       "developer",
       [
         "files",
+        "network",
         "processes",
       ],
     ],

package/scripts/josh/josh-commands-project.ts

@@ -26,7 +26,11 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 		script: 'scripts/init/init.ts',
 		description: 'Initialize config in a new project',
 		category: 'Project',
-		reference: [PROFILE_ARGUMENTS, 'developer', ['files', 'processes']],
+		reference: [
+			`${PROFILE_ARGUMENTS} [--no-install]`,
+			'developer',
+			['files', 'network', 'processes'],
+		],
 	},
 	sync: {
 		script: 'scripts/sync/sync.ts',

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

@@ -52,9 +52,9 @@ const WORKFLOW_COMMANDS: Record<string, CommandEntry> = {
 		reference: ['--task-type <type> --body <text>', 'automation', ['notifications']],
 		tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
 	},
-	// The observation ledger's only commit path (joshuafolkken/kit#1756). `pnpm josh git` excludes the
-	// ledger from what it stages, so without this command a parent's appended line has no route to the
-	// default branch at all — and the recurrence count the promotion rule reads is a count of main.
+	// The observation ledger's commit path for the lines no run's own commit carried
+	// (joshuafolkken/kit#1756, joshuafolkken/kit#2763): a lane's lines sit in the primary checkout, which
+	// its commit cannot see, and the recurrence count the promotion rule reads is a count of main.
 	'observations:flush': {
 		script: 'scripts/observations/observations-flush-cli.ts',
 		description: 'Commit the observation ledger as a pull request of its own, and merge it',

package/scripts/observations/observation-ledger-prepare.ts

@@ -0,0 +1,31 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import { OBSERVATION_LEDGER_PATH } from './observation-ledger'
+import { observation_ledger_line, type BrokenLine } from './observation-ledger-line'
+import { observation_ledger_migrate } from './observation-ledger-migrate'
+
+// **What has to hold before a ledger line is committed, asked by both of the paths that commit one**
+// (joshuafolkken/kit#2763): `pnpm josh observations:flush` and the run's own commit in
+// `scripts/git/git-staging.ts`. Lines still on the old path are moved first (joshuafolkken/kit#2724),
+// so the commit carries the move and the lines together, and every entry line is then parsed against
+// the grammar (joshuafolkken/kit#2123) — each caller decides what a broken line costs it.
+//
+// **A ledger that is not there has no line to break** — the change a status saw is then its deletion,
+// and a commit carries that like any other change to it.
+async function read_ledger(root: string): Promise<string> {
+	try {
+		return await readFile(path.join(root, OBSERVATION_LEDGER_PATH), 'utf8')
+	} catch {
+		return ''
+	}
+}
+
+async function prepare(root: string): Promise<ReadonlyArray<BrokenLine>> {
+	observation_ledger_migrate.migrate(root)
+
+	return observation_ledger_line.broken_ledger_lines(await read_ledger(root))
+}
+
+const observation_ledger_prepare = { prepare }
+
+export { observation_ledger_prepare }

package/scripts/observations/observation-ledger.ts

@@ -1,9 +1,8 @@
 // The observation ledger's one path, named here rather than inside any of the places that act on it
-// (joshuafolkken/kit#1756). `git-staging.ts` excludes it from every ordinary commit,
-// `hook-gate-reuse.ts` excludes it from what a hook calls a carried tree, and
-// `observations-flush.ts` is the only thing that stages it — so a literal in each would be three
-// answers to one question, and a rename reaching only some of them would silently restore the
-// contamination the exclusion exists to prevent.
+// (joshuafolkken/kit#1756). `git-staging.ts` stages it with the run's own commit when its grammar
+// holds (joshuafolkken/kit#2763), `hook-gate-reuse.ts` excludes it from what a hook calls a carried
+// tree, and `observations-flush.ts` commits what no run carried — so a literal in each would be three
+// answers to one question, and a rename reaching only some of them would silently split them.
 //
 // **It sits under `docs/maintainers/`, apart from the reader-facing documents** (joshuafolkken/kit#2724).
 const OBSERVATION_LEDGER_PATH = 'docs/maintainers/observations.md'
@@ -70,6 +69,7 @@ const observation_ledger = {
 	has_pending_append,
 	is_ledger_line,
 	is_ledger_path,
+	is_migration_claim,
 	ledger_paths,
 	status_path,
 }

package/scripts/observations/observations-flush.ts

@@ -1,17 +1,15 @@
-import { readFile } from 'node:fs/promises'
 import { git_command } from '#scripts/git/git-command'
 import { git_gh_command } from '#scripts/git/git-gh-command'
 import { main_sync } from '#scripts/git/main-sync'
 import { observation_ledger, OBSERVATION_LEDGER_PATH } from './observation-ledger'
-import { observation_ledger_line, type BrokenLine } from './observation-ledger-line'
-import { observation_ledger_migrate } from './observation-ledger-migrate'
+import type { BrokenLine } from './observation-ledger-line'
+import { observation_ledger_prepare } from './observation-ledger-prepare'
 import { observations_flush_landing } from './observations-flush-landing'
 
-// The commit path the observation ledger did not have (joshuafolkken/kit#1756). The parent session
-// that appends a line never runs `pnpm josh git`; a child runs it inside a lane work tree, which
-// cannot see the parent's checkout at all; and in the primary checkout `git add -u` swept the line
-// into whatever unrelated pull request that run was opening. So the ledger is excluded from ordinary
-// staging (`scripts/git/git-staging.ts`) and this is the one thing that stages it.
+// The commit path for the ledger lines no run's own commit carried (joshuafolkken/kit#1756). A run in
+// the primary checkout commits its appended lines with its own pull request (`scripts/git/
+// git-staging.ts`, joshuafolkken/kit#2763), so what is left here is a lane's lines — they sit in the
+// primary checkout, which a lane's commit cannot see — and whatever was appended after a commit.
 //
 // **The shape is `scripts/release/release-publish.ts`'s, deliberately.** Both open a pull request of
 // their own over one path, wait on the same required checks every other pull request waits on, and
@@ -57,7 +55,7 @@ function branch_name_for(stamp: string): string {
 // single issue, and the ledger's own lines say where each one was seen.
 function pull_request_body(): string {
 	return [
-		`Appended observations from \`${OBSERVATION_LEDGER_PATH}\`, which \`pnpm josh git\` never stages.`,
+		`Appended observations from \`${OBSERVATION_LEDGER_PATH}\` that no run's own commit carried.`,
 		'',
 		'The ledger is append-only, and a second line under one key is what promotes an observation to an issue — so this pull request adds lines and changes none.',
 		'',
@@ -373,31 +371,14 @@ function broken_lines_message(broken: ReadonlyArray<BrokenLine>): string {
 
 // **A malformed line is refused before a branch is cut, not after.** The ledger path was collected
 // without a line ever being parsed (joshuafolkken/kit#2123), so a broken append could ride a flush
-// through; validating here keeps the committed ledger to its grammar.
-//
-// **A ledger that is not there has no line to break** — the change the status saw is then its
-// deletion, and a flush commits that like any other change to it.
-async function read_ledger(): Promise<string> {
-	try {
-		return await readFile(OBSERVATION_LEDGER_PATH, 'utf8')
-	} catch {
-		return ''
-	}
-}
-
-async function refuse_broken_ledger(): Promise<void> {
-	const broken = observation_ledger_line.broken_ledger_lines(await read_ledger())
+// through; validating here keeps the committed ledger to its grammar. The migration and the parse are
+// `observation-ledger-prepare.ts`'s, shared with the run's own commit (joshuafolkken/kit#2763).
+async function prepare_ledger(): Promise<void> {
+	const broken = await observation_ledger_prepare.prepare(process.cwd())
 
 	if (broken.length > 0) throw new Error(broken_lines_message(broken))
 }
 
-// Lines still on the ledger's old path are moved before anything is validated or staged
-// (joshuafolkken/kit#2724), so the flush commits the move and the lines together.
-async function prepare_ledger(): Promise<void> {
-	observation_ledger_migrate.migrate(process.cwd())
-	await refuse_broken_ledger()
-}
-
 // **Nothing pulls in front of the branch, and that is deliberate.** The ledger is dirty by
 // definition at this point, so `git pull --ff-only` aborts on it in exactly the case a pull would
 // have been for — an upstream flush that already advanced the ledger — and reports a failure about

package/scripts/rules/implementation-cut.ts

@@ -63,6 +63,9 @@ interface LaneCostState {
 	directory: string
 	source: MarkerSource
 	carried: (now?: Date) => RunCut | undefined
+	// The issue whose run hold stands over this checkout (joshuafolkken/kit#2760) — how a `fullrun`
+	// held outside a lane is told apart from a person's tree.
+	held_issue: () => string | undefined
 	verdict: () => CostVerdict
 }
 
@@ -71,6 +74,7 @@ function current_state(): LaneCostState {
 		directory: process.cwd(),
 		source: process.env,
 		carried: run_cut.carried_cut_sync,
+		held_issue: run_cut.held_issue_sync,
 		// **Read through the short reuse window** (joshuafolkken/kit#2385). The row now fires per
 		// threshold crossing rather than once per run, so this predicate is a candidate on every edit;
 		// the window collapses one turn's burst of edits to a single whole-transcript price.
@@ -79,22 +83,49 @@ function current_state(): LaneCostState {
 	}
 }
 
-// A dispatched lane child for this checkout with no cut already carried. The dispatch mark is what
-// tells a child apart from a person (joshuafolkken/kit#1904), read from the environment against this
-// lane's own issue so a leaked mark for another issue reads as a person. **The carried-cut half keeps
-// the guard silent between a cut and its resume**, exactly as `pre-gate-cut.ts`'s does: a record naming
-// this issue means a cut is already in flight, and `begin_cut`'s exclusive create would refuse a second
-// one anyway.
-function uncut_lane_child_issue(state: LaneCostState): string | undefined {
+// A dispatched lane child's issue for this checkout. The dispatch mark is what tells a child apart from
+// a person (joshuafolkken/kit#1904), read from the environment against this lane's own issue so a
+// leaked mark for another issue reads as a person.
+function lane_child_issue(state: LaneCostState): string | undefined {
 	if (!lane_child_marker.is_child_of(state.directory, state.source)) return undefined
 
-	const issue = lane_paths.lane_issue_of(state.directory, { ...state.source })
+	return lane_paths.lane_issue_of(state.directory, { ...state.source })
+}
+
+// The issue a run holds this checkout for, read only outside a lane: a lane's hold is its dispatched
+// child's, so a person finishing that lane's work carries no mark and still sees no refusal.
+function held_run_issue(state: LaneCostState): string | undefined {
+	if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== undefined) return undefined
+
+	return state.held_issue()
+}
+
+// The run this checkout's edits belong to, with no cut already carried — a dispatched lane child, or
+// **a `fullrun` held in its own checkout** (joshuafolkken/kit#2760): the cut was lane-only, so a run a
+// person started grew without a bound mid-implementation. The run hold naming an issue is what marks
+// such a run, and a person's tree holds nothing, so it still sees no refusal. **The carried-cut half
+// keeps the guard silent between a cut and its resume**, exactly as `pre-gate-cut.ts`'s does: a record
+// naming this issue means a cut is already in flight, and `begin_cut`'s exclusive create would refuse
+// a second one anyway.
+function uncut_run_issue(state: LaneCostState): string | undefined {
+	const issue = lane_child_issue(state) ?? held_run_issue(state)
 
 	if (issue === undefined) return undefined
 
 	return state.carried()?.issue === issue ? undefined : issue
 }
 
+// **An unmeasurable session is cut in a lane and left alone outside one.** A lane child's safety net is
+// the pre-gate direction below; a held run outside a lane is a person's own session, so only a measured
+// `over` interrupts it — a provider with no transcript would otherwise refuse every edit it makes.
+function warrants_the_cut(state: LaneCostState): boolean {
+	const verdict = state.verdict()
+
+	if (lane_child_issue(state) === undefined) return verdict === cost_verdict.OVER_VERDICT
+
+	return verdict !== cost_verdict.UNDER_VERDICT
+}
+
 // **The tool-name test comes first and the world is consulted second, the cost measurement last.** This
 // predicate is asked of every call in the run, so the `Edit` / `Write` string match keeps the lane read
 // off all but the edits, and the lane read keeps the transcript-priced verdict off every edit but those
@@ -109,9 +140,9 @@ function is_over_threshold_edit(
 	call: GuardedCall,
 	state: LaneCostState = current_state(),
 ): boolean {
-	if (!is_edit_tool(call.name) || uncut_lane_child_issue(state) === undefined) return false
+	if (!is_edit_tool(call.name) || uncut_run_issue(state) === undefined) return false
 
-	return state.verdict() !== cost_verdict.UNDER_VERDICT
+	return warrants_the_cut(state)
 }
 
 // **The threshold in the refusal text is assembled from the constant, never spelled** (joshuafolkken/kit#2385).
@@ -125,7 +156,8 @@ const THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-toke
 // because `cut` is the only one that ends the turn and a run told merely to "take the cut" would have to
 // read which of the others leave it implementing — the same reason `pre-gate-cut.ts` spells them out.
 const IMPLEMENTATION_CUT_REASON =
-	'⛔ implementation-phase cut: this checkout is a lane dispatched for this issue and its recent-context ' +
+	'⛔ implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for ' +
+	'this issue (joshuafolkken/kit#2760), and its recent-context ' +
 	`cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated ` +
 	'so far is now re-read on every later request. Take the cut before this edit. ' +
 	'First write a handoff file with the Write tool — the user’s instruction verbatim, what you have ' +
@@ -139,11 +171,12 @@ const IMPLEMENTATION_CUT_REASON =
 	'because the verdict was only ever read at session entry, where the context has not yet grown. The ' +
 	"verdict is `pnpm josh cost --cut`'s exactly — the same per-request billed-input statistic against the " +
 	'same threshold, never a second measurement. Issue `pnpm josh run:cut --impl <N> --handoff <path>` now and read the ' +
-	'verdict: on `cut`, **end the turn immediately** — the fresh process owns the run and continues ' +
-	'implementing, so it must not be waited for; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
+	'verdict: on `cut`, **end the turn immediately** — in a lane the fresh process owns the run and ' +
+	'continues implementing, so it must not be waited for; outside a lane nothing is relaunched, so first ' +
+	'send the `confirmation` Telegram naming the resume command `fullrun #<N>` and keep the hold; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
 	'`unknown`, this process carries the run on and the edit is simply the next call. Never relaunch a ' +
-	'second process after `busy`. This fired because the dispatch mark names this lane; a person working ' +
-	'here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The ' +
+	'second process after `busy`. This fired because the dispatch mark names this lane or the run hold ' +
+	'names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The ' +
 	'procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue this edit once the cut has ' +
 	'answered — an edit reissued right after this refusal passes, so `busy` / `failed` cannot wedge the ' +
 	'run edit after edit; this fires again on the next threshold crossing rather than once per run.'
@@ -195,7 +228,7 @@ const implementation_cut = {
 	is_over_threshold_edit,
 	is_reissued_refusal,
 	takes_the_impl_cut,
-	uncut_lane_child_issue,
+	uncut_run_issue,
 }
 
 export type { LaneCostState }

package/scripts/rules/lane-background.ts

@@ -3,7 +3,10 @@ import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { json_value } from '#scripts/lib/json-value'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { time_shell } from '#scripts/time-runtime/time-shell'
-import { time_transcript_line } from '#scripts/time-runtime/time-transcript-line'
+import {
+	time_transcript_line,
+	type Block as TranscriptBlock,
+} from '#scripts/time-runtime/time-transcript-line'
 import { run_tail } from './run-tail'
 
 // A dispatched lane child is stopped from backgrounding a long-running josh command (joshuafolkken/kit#2704).
@@ -60,16 +63,32 @@ function is_background_long_run(
 	return is_candidate(call) && is_lane_child()
 }
 
-// The background tasks the transcript tail launched and never saw finish. A launch is read off its own
-// tool result and a finish off the harness notice, both by `time_transcript_line`.
-function pending_background_ids(tail: string): ReadonlyArray<string> {
+// The launches `launched_ids` reads off the transcript tail that never saw their finish. A launch is
+// read off its own tool result and a finish off the harness notice, both by `time_transcript_line`.
+function unfinished_ids(
+	tail: string,
+	launched_ids: (block: TranscriptBlock) => ReadonlyArray<string>,
+): ReadonlyArray<string> {
 	const lines = tail.split('\n').map((line) => time_transcript_line.parse_line(line))
 	const finished = new Set(lines.map((line) => line?.finished_background ?? ''))
-	const launched = lines.flatMap((line) => line?.blocks.map((block) => block.background_id) ?? [])
+	const blocks = lines.flatMap((line) => line?.blocks ?? [])
+	const launched = blocks.flatMap((block) => launched_ids(block))
 
 	return launched.filter((id) => id !== '' && !finished.has(id))
 }
 
+// The background tasks the tail launched and never saw finish — commands and subagents alike
+// (joshuafolkken/kit#2774), since a lane child's turn-end kills either.
+function pending_background_ids(tail: string): ReadonlyArray<string> {
+	return unfinished_ids(tail, (block) => [block.background_id, block.agent_id])
+}
+
+// The backgrounded subagents alone. A subagent always ends and its notice re-invokes the session; a
+// command may be a server that never exits, so only this set says the run is certain to resume.
+function pending_agent_ids(tail: string): ReadonlyArray<string> {
+	return unfinished_ids(tail, (block) => [block.agent_id])
+}
+
 const LANE_BACKGROUND_REASON =
 	'⛔ lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless ' +
 	'`claude -p` process whose background Bash tasks are killed when the turn ends — so a backgrounded ' +
@@ -105,6 +124,7 @@ const lane_background = {
 	LANE_BACKGROUND_STOP_REASON,
 	ROW,
 	is_background_long_run,
+	pending_agent_ids,
 	pending_background_ids,
 }