@joshuafolkken/kit 1.1178.0 → 1.1240.0

package/scripts/run/{run-cut-args.ts → cut/run-cut-args.ts}

@@ -1,5 +1,5 @@
 import { cli_flags } from '#scripts/lib/cli-flags'
-import { run_issue_number } from './run-issue-number'
+import { run_issue_number } from '#scripts/run/run-issue-number'
 
 // `josh run:cut` turns its `argv` into one of four requests. The contract mirrors `run-carry-args.ts`:
 // parsing lives here, acting on the record lives in `run-cut-cli.ts`, and a malformed command line is

package/scripts/run/{run-cut-cli.ts → cut/run-cut-cli.ts}

@@ -6,12 +6,12 @@ import { git_command } from '#scripts/git/git-command'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { lane_relaunch } from '#scripts/lane/lane-relaunch'
 import { openai_lane_supervisor } from '#scripts/lane/openai-lane-supervisor'
+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_cut, type CutState, type RunCut } from './run-cut'
 import { run_cut_args, type Request } from './run-cut-args'
 import { run_cut_handoff } from './run-cut-handoff'
 import { run_cut_report } from './run-cut-report'
-import { run_event_stream } from './run-event-stream'
-import { run_event_stream_emit } from './run-event-stream-emit'
 
 // `josh run:cut` — the record that lets a lane child end its process before the gate and a fresh one
 // resume from it (joshuafolkken/kit#1839). `run:cut <N>` writes the record and relaunches a fresh
@@ -290,14 +290,27 @@ function announce_handoff(cut_record: RunCut): void {
 	}
 }
 
-function adopt(target: string, cut_record: RunCut): number {
+// **An implementation resume appends a `resume` event** (joshuafolkken/kit#3375). It clears the record
+// the `cut` event stood for, so the stream is what moves `run:step` back to implementation; a pre-gate
+// resume keeps its record and appends nothing. Best-effort, as the cut's own append is.
+async function emit_resume_event(issue: string, verdict: string): Promise<void> {
+	if (verdict !== RESUME_IMPL_VERDICT) return
+
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.RESUME, `#${issue} resumed`)
+}
+
+async function adopt(target: string, cut_record: RunCut): Promise<number> {
 	const taken = take_over(target, cut_record)
 
 	if (taken === undefined) return report_busy(cut_record)
 
 	announce_handoff(cut_record)
 
-	return report(resume_verdict_for(cut_record), SUCCESS_EXIT_CODE)
+	const verdict = resume_verdict_for(cut_record)
+
+	await emit_resume_event(cut_record.issue, verdict)
+
+	return report(verdict, SUCCESS_EXIT_CODE)
 }
 
 // A relaunched lane child and a fresh session both measure `under`, so only the session that took an
@@ -329,7 +342,7 @@ async function verify_and_adopt(
 
 	if (is_over_threshold_resume(cut_record)) return report_over()
 
-	return adopt(target, cut_record)
+	return await adopt(target, cut_record)
 }
 
 async function resume(target: string, issue: string): Promise<number> {

package/scripts/run/{run-cut.ts → cut/run-cut.ts}

@@ -5,9 +5,9 @@ import { git_command } from '#scripts/git/git-command'
 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 { run_hold, type RunHold } from '#scripts/run/hold/run-hold'
 import { z } from 'zod'
 import { run_cut_handoff, type Handoff } from './run-cut-handoff'
-import { run_hold, type RunHold } from './run-hold'
 
 // joshuafolkken/kit#1839: a lane child is a detached `fullrun #<N>` process, and the thinking it
 // accumulates while implementing rides on every later API call in the same session — measured at 176K

package/scripts/run/{run-entry-cli.ts → entry/run-entry-cli.ts}

@@ -2,19 +2,19 @@
 import { fileURLToPath } from 'node:url'
 import { josh_command } from '#scripts/josh/josh-run'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
-import { run_cut_report } from './run-cut-report'
+import { run_cut_report } from '#scripts/run/cut/run-cut-report'
+import { run_hold_cli } from '#scripts/run/hold/run-hold-cli'
+import { run_halfrun_resume } from '#scripts/run/run-halfrun-resume'
+import { run_label } from '#scripts/run/run-label'
+import { run_next } from '#scripts/run/run-next'
+import { run_prep } from '#scripts/run/run-prep'
+import { run_prep_cli } from '#scripts/run/run-prep-cli'
+import { run_prrun_resume } from '#scripts/run/run-prrun-resume'
+import { run_stage, type StageCommand, type StageDecision } from '#scripts/run/run-stage'
+import { run_stage_read, type StageRead } from '#scripts/run/run-stage-read'
+import { run_step } from '#scripts/run/run-step'
 import { run_entry, type EntryParts } from './run-entry'
 import { run_entry_stop } from './run-entry-stop'
-import { run_halfrun_resume } from './run-halfrun-resume'
-import { run_hold_cli } from './run-hold-cli'
-import { run_label } from './run-label'
-import { run_next } from './run-next'
-import { run_prep } from './run-prep'
-import { run_prep_cli } from './run-prep-cli'
-import { run_prrun_resume } from './run-prrun-resume'
-import { run_stage, type StageCommand, type StageDecision } from './run-stage'
-import { run_stage_read, type StageRead } from './run-stage-read'
-import { run_step } from './run-step'
 
 // `josh run:entry <N>` — one call for the fixed entry sequence a lane opens on (joshuafolkken/kit#2372).
 // The loop used to spend a round trip on `run:hold`, one on `cost --cut`, one on `run:prep` and one on

package/scripts/run/{run-entry.ts → entry/run-entry.ts}

@@ -1,5 +1,5 @@
-import { run_hold_cli } from './run-hold-cli'
-import { run_step } from './run-step'
+import { run_hold_cli } from '#scripts/run/hold/run-hold-cli'
+import { run_step } from '#scripts/run/run-step'
 
 // `josh run:entry <N>` — the one call a `fullrun` makes to open a run (joshuafolkken/kit#2372). It
 // folds the fixed entry sequence a lane spends four separate round trips on — claim the tree

package/scripts/run/{run-event-render.ts → event/run-event-render.ts}

@@ -28,6 +28,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	split: { ja: '分割', en: 'split' },
 	outage: { ja: '障害', en: 'outage' },
 	cut: { ja: 'セッション交代', en: 'session cut' },
+	resume: { ja: '実装を再開', en: 'implementation resumed' },
 	drain: { ja: 'バックログが空', en: 'backlog drained' },
 	stop: { ja: '停止', en: 'stopped' },
 	'pr-opened': { ja: 'PR 作成', en: 'PR opened' },

package/scripts/run/{run-event-scope.ts → event/run-event-scope.ts}

@@ -1,4 +1,4 @@
-import type { CarryRead } from './run-carry'
+import type { CarryRead } from '#scripts/run/carry/run-carry'
 import { run_event_stream, type RunEvent } from './run-event-stream'
 
 // The one place a stream consumer scopes the event stream to a single invocation (joshuafolkken/kit#2395).

package/scripts/run/{run-event-stream-emit.ts → event/run-event-stream-emit.ts}

@@ -1,5 +1,5 @@
 import { error_text } from '#scripts/lib/error-message'
-import { run_carry } from './run-carry'
+import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_event_scope } from './run-event-scope'
 import { run_event_stream, type RunEvent } from './run-event-stream'
 

package/scripts/run/{run-event-stream.ts → event/run-event-stream.ts}

@@ -48,6 +48,10 @@ const EVENT_KIND = {
 	SPLIT: 'split',
 	OUTAGE: 'outage',
 	CUT: 'cut',
+	// A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`
+	// (joshuafolkken/kit#3375). The resume clears the cut record, so without this the `cut` stayed the
+	// newest position and `run:step` kept answering the resume command it had just run.
+	RESUME: 'resume',
 	// The backlog emptied while nothing of the run's own was in flight — the drain
 	// (joshuafolkken/kit#2335). It marks the position at which the end-of-run retrospective is owed,
 	// *before* the idle watch opens, so `run:step` fires the retrospective at the drain rather than after
@@ -168,6 +172,20 @@ function last_position(events: ReadonlyArray<RunEvent>): number {
 
 // The bounded stream serialized back to JSONL. The newest `EVENT_CAP` are kept and the oldest roll off;
 // each survivor keeps its original `pos`, so the bound never renumbers a position a reader is holding.
+// The stream held to `EVENT_CAP`, dropping the oldest trace events before any position
+// (joshuafolkken/kit#3245). A long run's ship-stage and heartbeat lines once filled 396 of the 500 slots
+// and pushed its cuts off, so the retrospective counted `cut 0` for a run with thirteen; a trace says only
+// that the run was alive, so it is the first to go. Only a stream of positions alone rolls them off.
+function bounded(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
+	const excess = events.length - EVENT_CAP
+
+	if (excess <= 0) return events
+
+	const dropped = new Set(events.filter((event) => TRACE_KINDS.has(event.kind)).slice(0, excess))
+
+	return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP)
+}
+
 function serialize(events: ReadonlyArray<RunEvent>): string {
 	return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`
 }
@@ -184,9 +202,9 @@ function append(target: string, kind: string, text: string, at: string): AppendR
 
 	const existing = read_events(target)
 	const position = last_position(existing) + POSITION_INCREMENT
-	const bounded = [...existing, { pos: position, at, kind, text }].slice(-EVENT_CAP)
+	const events = bounded([...existing, { pos: position, at, kind, text }])
 
-	stamp_file.write_text_stamp(target, serialize(bounded))
+	stamp_file.write_text_stamp(target, serialize(events))
 
 	return { appended: true, position }
 }

package/scripts/run/{run-hold-cli.ts → hold/run-hold-cli.ts}

@@ -1,11 +1,11 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { run_halfrun_resume } from './run-halfrun-resume'
+import { run_halfrun_resume } from '#scripts/run/run-halfrun-resume'
+import { run_label } from '#scripts/run/run-label'
+import { run_preflight, type PreflightDecision } from '#scripts/run/run-preflight'
+import { run_prrun_resume } from '#scripts/run/run-prrun-resume'
+import { run_tidy_cli } from '#scripts/run/tidy/run-tidy-cli'
 import { run_hold, type HoldRead, type RunHold } from './run-hold'
-import { run_label } from './run-label'
-import { run_preflight, type PreflightDecision } from './run-preflight'
-import { run_prrun_resume } from './run-prrun-resume'
-import { run_tidy_cli } from './run-tidy-cli'
 
 // `josh run:hold [<N>]` and `josh run:release [<N> | --force]` — the working-tree guard the typed
 // entry points ask before they start (joshuafolkken/kit#1091).

package/scripts/run/{run-merge-cli.ts → merge/run-merge-cli.ts}

@@ -5,12 +5,13 @@ import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-thresho
 import { issue_closing_pr } from '#scripts/issue/issue-closing-pr'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { lane_handoff } from '#scripts/lane/lane-handoff'
+import { lane_ledger } from '#scripts/lane/lane-ledger'
 import { cli_flags } from '#scripts/lib/cli-flags'
-import { run_carry, type CarryOwner, type RunCarry } from './run-carry'
-import { run_ending } from './run-ending'
-import { run_event_stream } from './run-event-stream'
-import { run_event_stream_emit } from './run-event-stream-emit'
-import { run_issue_number } from './run-issue-number'
+import { run_carry, type CarryOwner, type RunCarry } from '#scripts/run/carry/run-carry'
+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'
+import { run_issue_number } from '#scripts/run/run-issue-number'
 import { run_merge, type ChildOutcome, type EndingSignals } from './run-merge'
 import { run_merge_steps, type MergeContext } from './run-merge-steps'
 
@@ -234,6 +235,7 @@ async function on_merged(ctx: MergeContext): Promise<MergeVerdict> {
 	if (refused !== undefined) return report_count_refused(refused)
 
 	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.MERGE, `#${ctx.child} merged`)
+	await lane_ledger.record_merge(Number(ctx.child))
 
 	if (await run_merge_steps.is_over_budget(ctx.over)) return emit(OVER_TOKEN, SUCCESS_EXIT_CODE)
 
@@ -316,7 +318,10 @@ async function on_parked(ctx: MergeContext): Promise<MergeVerdict> {
 	return emit(await run_merge_steps.ask_next(ctx), SUCCESS_EXIT_CODE)
 }
 
+// A split child: nothing is counted, and its lane is closed when it holds nothing, so the promoted
+// epic does not keep a seat the next child needs (joshuafolkken/kit#3334).
 async function on_skipped(ctx: MergeContext): Promise<MergeVerdict> {
+	await run_merge_steps.close_split_lane(ctx.child)
 	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SPLIT, `#${ctx.child} split`)
 
 	return emit(await run_merge_steps.ask_next(ctx), SUCCESS_EXIT_CODE)

package/scripts/run/{run-merge-steps.ts → merge/run-merge-steps.ts}

@@ -9,9 +9,16 @@ import { lane_close } from '#scripts/lane/lane-close'
 import { lane_reap } from '#scripts/lane/lane-reap'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { lane_relaunch } from '#scripts/lane/lane-relaunch'
-import { run_carry, type CarryChange, type CarryOwner, type RunCarry } from './run-carry'
-import { run_carry_conversation } from './run-carry-conversation'
-import { run_cut, type RunCut } from './run-cut'
+import { lane_vacant } from '#scripts/lane/lane-vacant'
+import { poll } from '#scripts/lib/poll'
+import {
+	run_carry,
+	type CarryChange,
+	type CarryOwner,
+	type RunCarry,
+} from '#scripts/run/carry/run-carry'
+import { run_carry_conversation } from '#scripts/run/carry/run-carry-conversation'
+import { run_cut, type RunCut } from '#scripts/run/cut/run-cut'
 import { run_merge } from './run-merge'
 
 // The result of attempting to apply a carry change. Distinguishing `refused` from `applied` lets
@@ -38,6 +45,7 @@ const LANE_CLOSE_OCCASION = 'lane close'
 const GIT_ENTRY = '.git'
 const MERGE_CLOSER = 'pnpm josh run:merge'
 const SINGLE_READ = { attempts: 1, interval_ms: 0 }
+const SYNC_RETRY = { attempts: 3, interval_ms: 5000 }
 // What the driver judged when it parks a child, stated on the issue (joshuafolkken/kit#2769).
 const FAILED_CAUSE = 'the child’s session ended with its issue still open and unfinished.'
 const CUT_RELAUNCH_CAUSE =
@@ -125,10 +133,27 @@ async function refused_carry(ctx: MergeContext): Promise<RunCarry | undefined> {
 	return record.carry
 }
 
+// **A failed `main:sync` is retried before it ends the run** (joshuafolkken/kit#3323): one failure
+// right after a merge — measured while several lanes merged at once — stopped the whole drive, and a
+// hand-run `main:sync` minutes later succeeded. **The error carries the step's stderr, not its
+// stdout**: `main:sync` reports git's refusal on stderr, while stdout carries the wrapper's guard
+// statistics, which is all the old message showed.
 async function sync_main(): Promise<void> {
-	const result = await josh(['main:sync'])
+	// `poll_until` answers only whether it succeeded, so the last attempt's stderr is kept here.
+	let error_output = ''
 
-	if (result.code !== 0) throw new Error(`main:sync failed: ${result.out}`)
+	const is_synced = await poll.poll_until(
+		async () => {
+			const result = await josh(['main:sync'])
+
+			error_output = result.err ?? ''
+
+			return result.code === 0
+		},
+		{ ...SYNC_RETRY, sleeper: poll.sleep },
+	)
+
+	if (!is_synced) throw new Error(`main:sync failed: ${error_output}`)
 }
 
 async function close_lane(child: string): Promise<void> {
@@ -172,6 +197,28 @@ async function preserve_uncommitted(child: string): Promise<boolean> {
 	}
 }
 
+function kept_lane_comment(directory: string): string {
+	return `The split left this issue's lane open: it still holds a commit, an uncommitted change or a live process — ${directory}`
+}
+
+// A child promoted to an epic by a split leaves its lane holding a seat (joshuafolkken/kit#3334): the
+// epic root is never dispatched again, so nothing else would ever close it. The lane is closed only
+// when it holds nothing — no commit, no change, no live process (`lane_vacant`); any other lane is
+// kept, and why is stated on the issue.
+async function close_split_lane(child: string): Promise<void> {
+	const lane = await lane_registry.find_open_lane(child)
+
+	if (lane === undefined) return
+
+	if (await lane_vacant.is_vacant(lane)) {
+		await close_lane(child)
+
+		return
+	}
+
+	await git_gh_issue_write.issue_try_comment(child, kept_lane_comment(lane.directory))
+}
+
 // The progress comment is a human-readable mirror of the carry record, so it is best-effort and only
 // where a named epic has a body to carry it — a pure backlog run keeps the record alone.
 async function post_counters(ctx: MergeContext, carry: RunCarry | undefined): Promise<void> {
@@ -356,6 +403,7 @@ async function ask_next(ctx: MergeContext): Promise<string> {
 const run_merge_steps = {
 	CUT_RELAUNCH_CAUSE,
 	ask_next,
+	close_split_lane,
 	do_failed,
 	do_merged,
 	do_outage,

package/scripts/run/{run-merge.ts → merge/run-merge.ts}

@@ -5,7 +5,7 @@ import {
 	NEEDS_DECISION_LABEL,
 } from '#scripts/issue/issue-labels'
 import type { IssueState } from '#scripts/issue/issue-state'
-import type { CarryChange, RunCarry } from './run-carry'
+import type { CarryChange, RunCarry } from '#scripts/run/carry/run-carry'
 
 // joshuafolkken/kit#2024: a `backlogrun` merge event was two parent turns — a reading turn and an
 // acting turn — spent at the session whose context is largest and whose per-turn cost is highest.

package/scripts/run/{run-progress-cli.ts → progress/run-progress-cli.ts}

@@ -6,7 +6,7 @@ import { backlog_ready } from '#scripts/backlog/backlog-ready'
 import { gh_spawn } from '#scripts/gh/gh-spawn'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { error_text } from '#scripts/lib/error-message'
-import { run_event_stream_emit } from './run-event-stream-emit'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_progress, type ProgressState } from './run-progress'
 import { run_progress_args, type ParsedValues } from './run-progress-args'
 import { run_progress_clock } from './run-progress-clock'

package/scripts/run/{run-progress-config.ts → progress/run-progress-config.ts}

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs'
 import path from 'node:path'
+import { ancestor_directories } from '#scripts/lib/ancestor-directories'
 import { z } from 'zod'
 import { run_progress } from './run-progress'
 
@@ -28,10 +29,6 @@ import { run_progress } from './run-progress'
 
 const PACKAGE_FILE = 'package.json'
 
-// Deep enough to cross a workspace package and its root, and bounded so a path that never reaches a
-// root — a broken mount, a mocked `dirname` — cannot spin.
-const MAX_DEPTH = 10
-
 // Unknown keys are stripped rather than rejected: this reads a whole `package.json`, and every other
 // field in it is none of this module's business. A present-but-unusable interval fails the parse and
 // falls through, which is the same answer an unusable environment variable already gets.
@@ -39,18 +36,6 @@ const package_schema = z.object({
 	josh: z.object({ progress_interval_minutes: z.number().positive() }).optional(),
 })
 
-function ancestors_of(start: string): ReadonlyArray<string> {
-	const directories: Array<string> = []
-	let current = path.resolve(start)
-
-	while (directories.length < MAX_DEPTH && !directories.includes(current)) {
-		directories.push(current)
-		current = path.dirname(current)
-	}
-
-	return directories
-}
-
 function read_declared_minutes(directory: string): number | undefined {
 	try {
 		const raw = readFileSync(path.join(directory, PACKAGE_FILE), 'utf8')
@@ -63,7 +48,7 @@ function read_declared_minutes(directory: string): number | undefined {
 }
 
 function read_package_minutes(start: string): number | undefined {
-	for (const directory of ancestors_of(start)) {
+	for (const directory of ancestor_directories.list(start)) {
 		const minutes = read_declared_minutes(directory)
 
 		if (minutes !== undefined) return minutes

package/scripts/run/{run-progress-read.ts → progress/run-progress-read.ts}

@@ -1,13 +1,13 @@
 import { loadavg } from 'node:os'
 import { epic_busy } from '#scripts/epic/epic-busy'
 import { git_command } from '#scripts/git/git-command'
-import type { OpenIssueData } from '#scripts/git/schemas'
+import type { OpenIssueData } from '#scripts/git/git-schemas'
 import { lane_registry } from '#scripts/lane/lane-registry'
 import { lane_report } from '#scripts/lane/lane-report'
-import { run_carry, type CarryRead } from './run-carry'
-import { run_hold, type HoldRead } from './run-hold'
-import { run_liveness } from './run-liveness'
-import { run_preflight } from './run-preflight'
+import { run_carry, type CarryRead } from '#scripts/run/carry/run-carry'
+import { run_hold, type HoldRead } from '#scripts/run/hold/run-hold'
+import { run_liveness } from '#scripts/run/run-liveness'
+import { run_preflight } from '#scripts/run/run-preflight'
 import type { ChildObservation, LaneObservation, Observations } from './run-progress'
 import { run_progress_clock } from './run-progress-clock'
 

package/scripts/run/{run-progress.ts → progress/run-progress.ts}

@@ -257,7 +257,7 @@ interface LineTiming {
  * this is that same move for one value.
  *
  * **It is a schedule rather than an observation, and the two conditions on it are said in prose**
- * (`docs/josh-commands-automation.md` → `josh run:progress`): it holds only while the silence continues, and a
+ * (`docs/josh-commands-run.md` → `josh run:progress`): it holds only while the silence continues, and a
  * real report arriving first restarts the clock through `--mark` and supersedes it. The line printing
  * it is itself a report, so the clock starts at this observation.
  */

package/scripts/run/{run-review-steps.ts → review/run-review-steps.ts}

@@ -8,7 +8,7 @@ import { GATE_COMMAND } from '#scripts/josh/josh-command-types'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { review_stamps } from '#scripts/review/review-stamps'
 import { review_tree } from '#scripts/review/review-tree'
-import { detached_launch, type LaunchArgv, type LaunchResult } from './detached-launch'
+import { detached_launch, type LaunchArgv, type LaunchResult } from '#scripts/run/detached-launch'
 import { run_review, type GateState, type ReviewTiming, type TimingStart } from './run-review'
 
 // The side effects `josh run:review` performs, kept out of `run-review.ts` the way `run-merge-steps.ts`
@@ -114,8 +114,7 @@ function write_timing_start(start: TimingStart, target: string = PROJECT_ROOT):
 function to_timing(value: unknown): TimingStart | undefined {
 	if (typeof value !== 'object' || value === null) return undefined
 
-	const record = value as Record<string, unknown>
-	const { gate_started_at, review_started_at } = record
+	const { gate_started_at, review_started_at } = value as Record<string, unknown>
 
 	if (typeof gate_started_at !== 'string' || typeof review_started_at !== 'string') return undefined
 

package/scripts/run/run-ending.ts

@@ -4,8 +4,8 @@ import { api_outage } from '#scripts/agent/api-outage'
 import type { ClaudeResultEvent } from '#scripts/agent/claude-result-event'
 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'
+import { run_cut } from '#scripts/run/cut/run-cut'
+import { run_hold } from '#scripts/run/hold/run-hold'
 import { run_issue_number } from './run-issue-number'
 import { run_liveness } from './run-liveness'
 

package/scripts/run/run-halfrun-resume.ts

@@ -1,4 +1,9 @@
-import { run_hold, type HoldRead, type RunHold, type StopMarkFields } from './run-hold'
+import {
+	run_hold,
+	type HoldRead,
+	type RunHold,
+	type StopMarkFields,
+} from '#scripts/run/hold/run-hold'
 
 // joshuafolkken/kit#2796: a `halfrun` stops before its commit and **keeps** its hold, because the
 // uncommitted, hand-verified work is exactly what a second run would trample. The person then types

package/scripts/run/run-headless.ts

@@ -1,7 +1,7 @@
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { lane_reap } from '#scripts/lane/lane-reap'
 import { lane_registry } from '#scripts/lane/lane-registry'
-import { run_carry, type CarryRead, type RunCarry } from './run-carry'
+import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
 
 // The headless `backlogrun` parent (joshuafolkken/kit#2437). `run:wake` starts a cut's successor as
 // `claude -p`, and there a turn that ends is the process that ends: its background `lane:await` and