@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/scripts/rules/oracle-list-cli.ts

@@ -70,10 +70,7 @@ function main(argv: ReadonlyArray<string>): void {
 }
 
 const oracle_list_cli = {
-	format_oracle,
-	main,
 	print_list,
-	run,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))

package/scripts/rules/permission-guards.ts

@@ -0,0 +1,14 @@
+import { destructive_command } from './destructive-command'
+import { index_guard } from './index-guard'
+import { protected_files } from './protected-files'
+
+// The three rows that close the deny-list bypasses (joshuafolkken/kit#2983), gathered so
+// `delivered-rules.ts` spreads one entry. Each reads argv or a file path rather than a glob: an index
+// mutation in any git spelling, a recursive forced `rm` or a destructive `gh` call, and a Read of
+// `.env` or an edit of a consumer's `.claude/settings.json`. Their triggers are disjoint from every
+// other row's — `git restore` is split with `worktree-mutation` by `--staged` alone.
+const ROWS = [index_guard.ROW, destructive_command.ROW, protected_files.ROW] as const
+
+const permission_guards = { ROWS }
+
+export { permission_guards }

package/scripts/rules/pre-gate-cut.ts

@@ -44,8 +44,8 @@ const HOLD_COMMANDS: ReadonlySet<string> = new Set(['run:hold'])
 // predicate exists to keep it out of.
 const HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u
 
-// **Alias-expanded rather than matched as text**, so `pnpm josh ga` and `pnpm josh rct` are the same
-// calls as their canonical spellings. Segment-wise for the reason every other row here is: one shell
+// **Alias-expanded rather than matched as text**, so `pnpm josh ga` is the same call as `pnpm josh
+// gate`. Segment-wise for the reason every other row here is: one shell
 // line carries several commands, and a name quoted inside a body is not the command being invoked.
 //
 // **One reading of that question rather than one per name set.** Four predicates here differ only in

package/scripts/rules/protected-files.ts

@@ -0,0 +1,74 @@
+import path from 'node:path'
+import { doctor_consumer } from '#scripts/doctor/doctor-consumer'
+import { json_value } from '#scripts/lib/json-value'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+
+// The trigger and the delivered text behind the `protected-file` row of `delivered-rules.ts`
+// (joshuafolkken/kit#2983): the two files a run's own file tools must not touch.
+//
+// - **`.env` is never read.** It carries the Telegram bot token, and a Read lands it in the transcript.
+//   The scripts that need it load it in their own process, so refusing the tool costs them nothing.
+// - **`.claude/settings.json` is never edited in a consumer repository.** It is the deny list and the
+//   hooks that enforce every other rule, so a run that rewrites it can switch the guards off; `josh
+//   sync` owns it there. Only a kit consumer's file is refused — decided per file from the repository
+//   the settings file sits in, not the session's directory — so kit's own edits (it is the file's
+//   source) and the user-level `~/.claude/settings.json`, which belongs to no repository, both pass.
+//
+// It fires on every occurrence, for the reason `git-force.ts` does.
+
+const READ_TOOL = 'Read'
+const EDIT_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write'])
+const ENVIRONMENT_FILE = '.env'
+const SETTINGS_FILE = path.join('.claude', 'settings.json')
+
+function file_path_of(call: GuardedCall): string {
+	if (!json_value.is_record(call.input)) return ''
+
+	const value = call.input['file_path']
+
+	return typeof value === 'string' ? value : ''
+}
+
+function is_environment_read(call: GuardedCall): boolean {
+	return call.name === READ_TOOL && path.basename(file_path_of(call)) === ENVIRONMENT_FILE
+}
+
+// The repository the settings file belongs to is two levels above it (`<root>/.claude/settings.json`).
+function is_consumer_settings_edit(
+	call: GuardedCall,
+	is_kit_consumer: (root: string) => boolean,
+): boolean {
+	if (!EDIT_TOOLS.has(call.name)) return false
+
+	const file_path = path.resolve(file_path_of(call))
+
+	if (!file_path.endsWith(`${path.sep}${SETTINGS_FILE}`)) return false
+
+	return is_kit_consumer(path.dirname(path.dirname(file_path)))
+}
+
+function is_protected_file_call(
+	call: GuardedCall,
+	is_kit_consumer: (root: string) => boolean = doctor_consumer.is_kit_consumer,
+): boolean {
+	return is_environment_read(call) || is_consumer_settings_edit(call, is_kit_consumer)
+}
+
+const PROTECTED_FILE_REASON =
+	'⛔ protected file: `.env` holds the Telegram bot token, so reading it puts a secret in the ' +
+	'transcript — the scripts that need it load it in their own process. `.claude/settings.json` in a ' +
+	'consumer repository is the deny list and the hooks every other rule rests on, so a run must not ' +
+	'rewrite it; `josh sync` owns it, and a change belongs upstream in kit (`CLAUDE.md` → "Route ' +
+	'distributed-doc / config changes upstream to kit"). Leave both files alone, or ask the user. ' +
+	'**This rule fires on every occurrence, not once per run.**'
+
+const ROW = {
+	id: 'protected-file',
+	is_trigger: is_protected_file_call,
+	reason: PROTECTED_FILE_REASON,
+	decide: (): boolean => true,
+}
+
+const protected_files = { ROW, is_protected_file_call }
+
+export { protected_files }

package/scripts/rules/reply-language.ts

@@ -111,6 +111,6 @@ function is_mismatch(message: string, lang: string): boolean {
 	return matches_share(prose, script, pattern) < MATCH_SHARE_FLOOR
 }
 
-const reply_language = { MIN_PROSE_LETTERS, is_mismatch, script_of }
+const reply_language = { is_mismatch, script_of }
 
 export { reply_language }

package/scripts/rules/rule-body-guard.ts

@@ -192,11 +192,8 @@ const ROW = {
 const rule_body_guard = {
 	RULE_BODY_REASON,
 	ROW,
-	adds_rule_prose,
 	answered_placement,
 	is_rule_document,
-	prose_of,
-	runs_placement_oracle,
 	writes_rule_prose,
 }
 

package/scripts/rules/rule-value-cli.ts

@@ -117,7 +117,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 }
 
 const rule_value_cli = {
-	gather_runs,
 	group_by_run,
 	render,
 	row,

package/scripts/rules/shell-body-trigger.ts

@@ -196,7 +196,6 @@ const SHELL_BODY_REASON =
 const shell_body_trigger = {
 	SHELL_BODY_REASON,
 	carries_a_body,
-	is_safe_body_form,
 	is_shell_evaluated_body,
 	keeps_body_safe,
 }

package/scripts/rules/shell-segments.ts

@@ -37,7 +37,6 @@ function is_josh_command(segment: string, names: ReadonlySet<string>): boolean {
 }
 
 const shell_segments = {
-	SEGMENT_SEPARATOR,
 	is_josh_command,
 	segments_of,
 }

package/scripts/rules/stop-rules.ts

@@ -45,6 +45,9 @@ interface StopContext {
 	hold_present: boolean
 	// `git status --porcelain` came back empty.
 	tree_clean: boolean
+	// That record carries a `prrun` stop mark (joshuafolkken/kit#3023): the run stopped at a green pull
+	// request and keeps the hold over a clean tree on purpose, so a person can look before it merges.
+	prrun_stopped: boolean
 	// A `confirmation` notify is on this run's transcript tail.
 	notified: boolean
 	// The turn's session-facing reply text.
@@ -75,6 +78,9 @@ interface StopContext {
 	// A backgrounded subagent this run launched has not finished — `lane_background.pending_agent_ids`
 	// (joshuafolkken/kit#2774). Apart from `background_pending`, since only a subagent is sure to end.
 	agent_pending: boolean
+	// This lane child handed its region to a running detached ship — `lane_handoff.is_handed_off`
+	// (joshuafolkken/kit#2962). The supervisor notifies on its own outcome, so nobody waits on this stop.
+	handed_off: boolean
 	// The resolved `JOSH_SESSION_LANG` — `session_language.resolve_session_lang` (joshuafolkken/kit#2470).
 	session_lang: string
 }
@@ -105,8 +111,8 @@ const HOLD_RELEASE_REASON =
 	'place, so the next run here runs `git switch main && git pull` believing the tree is free while ' +
 	'you hold it. `.claude/skills/workflow-commands/SKILL.md` → §2f: a stop that leaves the tree clean ' +
 	'releases the hold with `pnpm josh run:release <N>` (bare for a `new` entry). A `halfrun` ' +
-	'pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty — this ' +
-	'row is silent there. Release it, then end with a one-line confirmation that it was released — do ' +
+	'pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty, and a ' +
+	'`prrun` stop keeps it by its stop mark — this row is silent there. Release it, then end with a one-line confirmation that it was released — do ' +
 	'not repeat your previous reply.'
 
 // **A refusal that corrects rather than advises** (joshuafolkken/kit#2247). The bare `#N` is already
@@ -232,8 +238,11 @@ function needs_filing(context: StopContext): boolean {
 // notify there says "nothing needed" and dilutes the ones that do. A backgrounded command does not
 // count: a dev server never ends, and a stop behind it would leave a person silently waiting. A lane
 // child never reaches this with a task running: `needs_background_wait` answers it first.
+//
+// **A lane handed to the detached ship stands them down too** (joshuafolkken/kit#2962): the hold now
+// belongs to the supervisor driving the merge, and the person hears from that supervisor's own notify.
 function is_held_idle(context: StopContext): boolean {
-	return context.hold_present && !context.agent_pending
+	return context.hold_present && !context.agent_pending && !context.handed_off
 }
 
 function needs_notify(context: StopContext): boolean {
@@ -241,7 +250,7 @@ function needs_notify(context: StopContext): boolean {
 }
 
 function needs_release(context: StopContext): boolean {
-	return is_held_idle(context) && context.tree_clean
+	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
 }
 
 function citation_reason(context: StopContext): string | undefined {
@@ -345,7 +354,6 @@ const stop_rules = {
 	STOP_NOTIFY_REASON,
 	SWITCH_ENV_KEY,
 	block_envelope,
-	block_reason,
 	build_language_reason,
 	count_headless_refusals,
 	is_enabled,

package/scripts/rules/tail-commands.ts

@@ -30,6 +30,6 @@ function prior_bash_commands(tail: string): ReadonlyArray<string> {
 	return tail.split('\n').flatMap((line) => bash_commands_of(line))
 }
 
-const tail_commands = { bash_commands_of, is_bash_use, prior_bash_commands }
+const tail_commands = { is_bash_use, prior_bash_commands }
 
 export { tail_commands }

package/scripts/rules/test-declared-commit.ts

@@ -46,6 +46,6 @@ const REASON =
 // reason above.
 const ROW = { id: 'test-declared', is_trigger: is_untested_commit, reason: REASON }
 
-const test_declared_commit = { REASON, ROW, is_untested_commit }
+const test_declared_commit = { REASON, ROW }
 
 export { test_declared_commit }

package/scripts/rules/third-party-write.ts

@@ -83,7 +83,6 @@ const ROW = {
 const third_party_write = {
 	ROW,
 	THIRD_PARTY_WRITE_REASON,
-	is_third_party_write_segment,
 	writes_third_party,
 }
 

package/scripts/rules/worktree-guard.ts

@@ -36,8 +36,8 @@ function is_worktree_checkout(args: ReadonlyArray<string>): boolean {
 }
 
 // `git restore <path>` discards working-tree changes. `--staged` / `-S` alone is an index restore —
-// that is the deny list's territory (`git restore --staged*` / `-S*`), so a pure index restore is not
-// refused twice. Anything touching the worktree (the default, or an explicit `--worktree` / `-W`) is.
+// that is the `index-mutation` row's (`index-guard.ts`), so a pure index restore is not claimed by two
+// rows. Anything touching the worktree (the default, or an explicit `--worktree` / `-W`) is this row's.
 const STAGED_LONG = '--staged'
 const STAGED_LETTER = 'S'
 const WORKTREE_LONG = '--worktree'
@@ -83,14 +83,33 @@ function is_unauthorized_stash(args: ReadonlyArray<string>): boolean {
 	return true
 }
 
+// `git clean` deletes untracked files, which no commit can bring back (joshuafolkken/kit#2983). It
+// refuses to act without a force (`clean.requireForce`), so a force — `--force`, or a cluster carrying
+// `f` — is what marks the destructive call; `git clean -n` is a dry run and passes.
+const CLEAN_SUBCOMMAND = 'clean'
+const FORCE_LONG = '--force'
+const FORCE_LETTER = 'f'
+
+function is_forced_clean(args: ReadonlyArray<string>): boolean {
+	return args.some(
+		(argument) => argument === FORCE_LONG || git_argv.short_cluster_has(argument, FORCE_LETTER),
+	)
+}
+
+// Each subcommand this row judges, with the predicate that reads its arguments.
+const JUDGED_SUBCOMMANDS: ReadonlyMap<string, (args: ReadonlyArray<string>) => boolean> = new Map([
+	[CHECKOUT_SUBCOMMAND, is_worktree_checkout],
+	[RESTORE_SUBCOMMAND, touches_worktree],
+	[CLEAN_SUBCOMMAND, is_forced_clean],
+	[STASH_SUBCOMMAND, is_unauthorized_stash],
+])
+
 function is_unauthorized_segment(segment: string): boolean {
 	const call = git_argv.parse(segment)
 
 	if (call === undefined) return false
-	if (call.subcommand === CHECKOUT_SUBCOMMAND) return is_worktree_checkout(call.args)
-	if (call.subcommand === RESTORE_SUBCOMMAND) return touches_worktree(call.args)
 
-	return call.subcommand === STASH_SUBCOMMAND && is_unauthorized_stash(call.args)
+	return JUDGED_SUBCOMMANDS.get(call.subcommand ?? '')?.(call.args) === true
 }
 
 function is_unauthorized_worktree_change(command: string): boolean {
@@ -101,8 +120,8 @@ function is_unauthorized_worktree_change(command: string): boolean {
 // and — for a stash — the message form that is allowed. `pnpm josh git` and `pnpm josh stash:pop` are
 // invisible to this trigger, so a run that uses them is never refused.
 const WORKTREE_MUTATION_REASON =
-	'⛔ unauthorized working-tree change: `git checkout -- <path>`, `git restore <path>` and an ' +
-	'unauthorized `git stash` mutate the working tree or the repository-wide stash every work tree ' +
+	'⛔ unauthorized working-tree change: `git checkout -- <path>`, `git restore <path>`, a forced ' +
+	'`git clean` and an unauthorized `git stash` discard work or mutate the repository-wide stash every work tree ' +
 	'shares, and none is on the `.claude/settings.json` deny list (`operating-rules.md`). Do not run ' +
 	'them on your own judgement. A commit goes through `pnpm josh git`; a stash pop goes through `pnpm ' +
 	'josh stash:pop "<message>"`, never a positional `git stash pop` a shared stack lets another lane ' +
@@ -121,9 +140,7 @@ const ROW = {
 const worktree_guard = {
 	ROW,
 	WORKTREE_MUTATION_REASON,
-	is_unauthorized_stash,
 	is_unauthorized_worktree_change,
-	is_worktree_checkout,
 	touches_worktree,
 }
 

package/scripts/run/run-carry-cli.ts

@@ -447,11 +447,9 @@ const run_carry_cli = {
 	RESUMED_VERDICT,
 	STANDING_VERDICT,
 	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	// Re-exported rather than restated: the usage line belongs to the half that parses, and a second
 	// copy of it here would drift from the flags it describes.
 	USAGE: run_carry_args.USAGE,
-	main,
 	run,
 }
 

package/scripts/run/run-carry-stash.ts

@@ -1,5 +1,5 @@
-import { git_stash } from '#scripts/git/git-stash'
-import { stash_orphans } from '#scripts/git/stash-orphans'
+import { git_stash } from '#scripts/git/stash/git-stash'
+import { stash_orphans } from '#scripts/git/stash/stash-orphans'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
 

package/scripts/run/run-carry-streak.ts

@@ -107,7 +107,7 @@ function next_state(carry: StreakCarry, change: StreakChange, now: Date): Streak
 	}
 }
 
-const run_carry_streak = { OUTAGE_FOLD_WINDOW_MS, next_state }
+const run_carry_streak = { next_state }
 
 export type { StreakCarry, StreakChange, StreakState }
 export { run_carry_streak }

package/scripts/run/run-cut-cli.ts

@@ -45,8 +45,6 @@ const {
 	STALE_VERDICT,
 	SUCCESS_EXIT_CODE,
 	UNDER_THRESHOLD_VERDICT,
-	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	UNREADY_VERDICT,
 	refuse_unready,
 	report,
@@ -423,18 +421,13 @@ const run_cut_cli = {
 	FAILED_VERDICT,
 	FRESH_VERDICT,
 	HANDED_OFF_VERDICT,
-	INCOMPLETE_VERDICT,
 	NOT_A_LANE_VERDICT,
 	OVER_VERDICT,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
 	STALE_VERDICT,
 	UNDER_THRESHOLD_VERDICT,
-	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	UNREADY_VERDICT,
-	USAGE: run_cut_args.USAGE,
-	main,
 	run,
 }
 

package/scripts/run/run-cut.ts

@@ -1,10 +1,8 @@
-import { execFileSync } from 'node:child_process'
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
-import { git_utilities } from '#scripts/git/constants'
 import { git_command } from '#scripts/git/git-command'
-import { git_location_environment } from '#scripts/git/git-location-environment'
+import { git_common_directory } from '#scripts/git/git-common-directory'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { lane_child_invocation } from '#scripts/lane/lane-child-invocation'
 import { z } from 'zod'
@@ -60,14 +58,6 @@ const IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD
 const CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS
 const CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS
 
-// The synchronous git read runs inside a `PreToolUse` hook, which holds the tool call for as long as
-// it takes; `rev-parse` takes no lock, so anything past a second is a fault rather than slow work.
-const GIT_READ_TIMEOUT_MS = 5000
-
-// The two lines `GIT_DIRECTORY_ARGUMENTS` prints, in order: the work tree's own git directory, then the
-// common one every lane of a repository shares. `git_directories` reads the same two asynchronously.
-const WORKTREE_DIRECTORY_INDEX = 0
-
 const END_COMMAND = 'pnpm josh run:cut --end'
 const READ_COMMAND = 'pnpm josh run:cut --json'
 
@@ -224,10 +214,10 @@ function read_cut(target: string, now: Date = new Date()): CutRead {
 
 // **The same read as `read_cut(cut_path(await worktree_directory()))`, taken synchronously**
 // (joshuafolkken/kit#1864). The pre-gate cut is enforced from a `PreToolUse` guard, and a guard
-// answers synchronously or not at all — so the one git call the path derivation needs is made here
-// with `git_command.GIT_DIRECTORY_ARGUMENTS`, the same argument list the asynchronous reader uses,
-// rather than a second spelling of it. Everything after the path is already shared: `cut_path` keys
-// the record and `classify` parses and expires it.
+// answers synchronously or not at all — so the one git call the path derivation needs is
+// `git_common_directory.own()`, the synchronous twin of the asynchronous reader, rather than a second
+// spelling of it. Everything after the path is already shared: `cut_path` keys the record and
+// `classify` parses and expires it.
 //
 // **A fault reads as "no cut was taken", and that direction is deliberate rather than fail-open.** A
 // checkout git cannot describe, a record that will not parse and an expired one all come back
@@ -235,47 +225,11 @@ function read_cut(target: string, now: Date = new Date()): CutRead {
 // The alternative errs the other way: a read fault would be taken for "already cut" and the guard
 // would go quiet on exactly the run it exists for. The cost of this direction is one refusal a lane
 // can answer by reissuing, since that row is delivered once per run.
-function git_directories_sync(cwd?: string): ReadonlyArray<string> {
-	try {
-		// The binary is resolved through `git_utilities` exactly as `git-spawn.ts` resolves it, so this
-		// call does not answer to whatever `PATH` happens to hold. It runs the binary directly with an
-		// argument array and no `shell` option, and both are internally controlled, never untrusted
-		// input.
-		const output = execFileSync(
-			git_utilities.get_git_command_for_spawn(),
-			[...git_command.GIT_DIRECTORY_ARGUMENTS],
-			// git's own diagnostics are discarded: a checkout it cannot describe is already the
-			// `undefined` below, and a hook that let `fatal: not a git repository` through would print it
-			// in front of a tool call that is about to be allowed.
-			// A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
-			// left to whatever git does.
-			// `cwd` is set only by `lane_cut_sync`, which reads another lane's record from the parent.
-			// With a `cwd`, the git location variables are cleared so it is what git answers for: a hook
-			// exports `GIT_DIR`, which beats `cwd` and would name the hook's checkout instead
-			// (joshuafolkken/kit#2515). Without one the environment is kept, so this read resolves the same
-			// checkout as the asynchronous `git_directories` that writes the record.
-			{
-				cwd,
-				env:
-					cwd === undefined
-						? process.env
-						: { ...process.env, ...git_location_environment.location_free_environment() },
-				encoding: 'utf8',
-				stdio: ['ignore', 'pipe', 'ignore'],
-				timeout: GIT_READ_TIMEOUT_MS,
-			},
-		) // NOSONAR
-
-		return output.split('\n').filter((line) => line !== '')
-	} catch {
-		return []
-	}
-}
-
+//
 // The work tree's own git directory (index 0), the same read `git_directories` makes asynchronously —
 // the record and the pre-gate guard both key on it.
 function worktree_git_directory_sync(): string | undefined {
-	return git_directories_sync()[WORKTREE_DIRECTORY_INDEX]
+	return git_common_directory.own()
 }
 
 // **The directory is injectable so a test never has to write to the live record.** Keyed to the work
@@ -297,7 +251,7 @@ function carried_cut_sync(
 // lane's own git directory, so the parent — standing in the main checkout — resolves that directory
 // from the lane's path rather than its own, and gets the record path back to mark it.
 function lane_cut_sync(lane_directory: string): { target: string; cut: RunCut } | undefined {
-	const directory = git_directories_sync(lane_directory)[WORKTREE_DIRECTORY_INDEX]
+	const directory = git_common_directory.own(lane_directory)
 
 	if (directory === undefined) return undefined
 

package/scripts/run/run-ending-cli.ts

@@ -101,7 +101,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const run_ending_cli = { USAGE, main, parse_request, run }
+const run_ending_cli = { USAGE, parse_request, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-ending.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs'
 import { agent_exit_record } from '#scripts/agent/agent-exit-record'
 import { api_outage } from '#scripts/agent/api-outage'
 import type { ClaudeResultEvent } from '#scripts/agent/claude-result-event'
-import { git_gh_issue_read } from '#scripts/git/git-gh-issue-read'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
 import { issue_state } from '#scripts/issue/issue-state'
 import { run_cut } from './run-cut'
 import { run_hold } from './run-hold'
@@ -222,9 +222,6 @@ async function check(request: EndingRequest): Promise<EndingDecision> {
 const run_ending = {
 	check,
 	decide,
-	describe_exit,
-	read_child_closed,
-	read_cut_taken,
 	read_exit,
 }