@joshuafolkken/kit 1.3044.0 → 1.3099.0

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

@@ -1,6 +1,6 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
 import type { ShipLapRecord } from '#scripts/lane/lane-ledger-schema'
 import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { inherited_scope } from '#scripts/lib/inherited-scope'
 import { z } from 'zod'
 
 // The inner steps of a `josh ship` stage, each timed into the lane ledger as a lap, so `lane:breakdown`
@@ -39,7 +39,7 @@ const STEP = {
 	COMMIT: 'josh git',
 } as const
 
-const scope = new AsyncLocalStorage<LapScope>()
+const scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema)
 
 async function to_ledger(lap: ShipLapRecord): Promise<void> {
 	await lane_ledger_write.record_ship_lap(lap)
@@ -51,23 +51,11 @@ async function within<T>(
 	run: () => Promise<T>,
 	parent?: string,
 ): Promise<T> {
-	return await scope.run({ issue: Number(issue), stage, parent }, run)
-}
-
-// The scope a parent process handed down, `undefined` when none or unreadable.
-function inherited(): LapScope | undefined {
-	const text = process.env[ENVIRONMENT_KEY]
-	if (text === undefined || text === '') return undefined
-
-	try {
-		return lap_scope_schema.safeParse(JSON.parse(text)).data
-	} catch {
-		return undefined
-	}
+	return await scope.within({ issue: Number(issue), stage, parent }, run)
 }
 
 function current_scope(): LapScope | undefined {
-	return scope.getStore() ?? inherited()
+	return scope.current()
 }
 
 // The environment that times a child process's steps under `parent`, `{}` outside any scope.
@@ -113,7 +101,7 @@ const startup = { recorded: false }
 // `timeOrigin` until that lap, the tsx load among it — so the parent's lap is explained by its
 // children (joshuafolkken/kit#5896). A scope this process opened with `within` started no process.
 async function record_startup(current: LapScope, sink: LapSink, is_wanted: boolean): Promise<void> {
-	if (!is_wanted || startup.recorded || scope.getStore() !== undefined) return
+	if (!is_wanted || startup.recorded || scope.local() !== undefined) return
 	startup.recorded = true
 
 	await sink(lap_of(current, STARTUP_STEP, 0, {}))

package/scripts/run/ship/run-ship-pre-detach-pinned.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto'
 import { check_reuse } from '#scripts/gate/check-reuse'
-import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import type { JoshResult } from '#scripts/josh/josh-run'
 import { buffered_process } from '#scripts/lib/buffered-process'
 import { error_text } from '#scripts/lib/error-message'
@@ -8,8 +7,8 @@ import { review_round_reuse } from '#scripts/review/review-round-reuse'
 import { run_review_pinned } from '#scripts/run/review/run-review-pinned'
 import { run_review_pinned_accepted } from '#scripts/run/review/run-review-pinned-accepted'
 import { run_review_pinned_join } from '#scripts/run/review/run-review-pinned-join'
+import { run_review_pinned_remaining } from '#scripts/run/review/run-review-pinned-remaining'
 import { run_review_pinned_steps } from '#scripts/run/review/run-review-pinned-steps'
-import { run_review_pinned_tree } from '#scripts/run/review/run-review-pinned-tree'
 import { test_pinned } from '#scripts/test/test-pinned'
 import { test_pinned_logic } from '#scripts/test/test-pinned-logic'
 import { test_pinned_record, type PinnedSummary } from '#scripts/test/test-pinned-record'
@@ -60,7 +59,7 @@ function remaining_note(remaining: number | undefined): string {
 	const hunks =
 		remaining === undefined ? 'the remaining hunks' : `${String(remaining)} remaining hunks`
 
-	return `test:pinned: probing ${hunks} in the background — the next ship's pre-detach reads their verdicts\n`
+	return `test:pinned: probing ${hunks} in the background — before editing or retrying ship, collect every verdict with \`pnpm josh run:review --pinned\`\n`
 }
 
 // **A stop at the first unpinned hunk leaves the rest probing in the background**
@@ -68,17 +67,9 @@ function remaining_note(remaining: number | undefined): string {
 // this tree, or waits it out on a fixed one so its verdicts reach the cache and only the hunks the fix
 // moved are probed again. A launch that failed or threw adds no note, and never fails the check.
 async function is_rest_launched(): Promise<boolean> {
-	try {
-		const tree = await run_review_pinned_tree.key()
-
-		run_review_pinned_steps.clear()
+	const launched = await run_review_pinned_remaining.start()
 
-		return run_review_pinned_steps.launch_remaining(PROJECT_ROOT, tree).kind === 'launched'
-	} catch (error) {
-		error_text.trace_swallowed('run_ship_pre_detach_pinned.is_rest_launched', error)
-
-		return false
-	}
+	return launched.kind === 'launched'
 }
 
 async function continued(answer: PinnedSummary): Promise<PinnedSummary> {

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

@@ -27,28 +27,51 @@ const REUSED_PAIR = 'scoped pair: reused — both checks are green on this tree'
 const RED_PAIR = 'scoped pair: red on this tree in this ship — not run again'
 
 type Phase = () => Promise<JoshResult>
+
+interface ScopedPhase {
+	script: string
+	run: () => Promise<JoshResult>
+}
+
 // A pair's result with the files it was named over, or why a merge could not split, for its lap.
-type PairResult = JoshResult & { note?: Pick<LapNote, 'named' | 'unsplit'> }
+type PairResult = JoshResult & { note?: Pick<LapNote, 'named' | 'unsplit'>; verified?: GateTree }
 
-async function run_phases(phases: ReadonlyArray<Phase>): Promise<JoshResult> {
+async function run_phases(
+	phases: ReadonlyArray<Phase>,
+	after_phase?: (index: number) => Promise<void>,
+): Promise<JoshResult> {
 	let last: JoshResult = { code: SUCCESS_EXIT_CODE, out: '' }
 
-	for (const phase of phases) {
-		// eslint-disable-next-line no-await-in-loop -- phases run in order and the first failure stops the rest
+	for (const [index, phase] of phases.entries()) {
+		// eslint-disable-next-line no-await-in-loop -- stop at the first failed phase
 		last = await phase()
+		// eslint-disable-next-line no-await-in-loop -- snapshot a completed writer before starting readers
+		await after_phase?.(index)
 		if (last.code !== SUCCESS_EXIT_CODE) return last
 	}
 
 	return last
 }
 
-// The tree after the branch's metrics approval is re-recorded (`metrics-totals.ts`): every review fix
-// and the gate stage meet the pair here, so a rewrite lands before any record is written for the tree.
-async function rerecorded_tree(): Promise<GateTree> {
-	const tree = await gate_tree.read_gate_tree()
-	const is_rerecorded = await metrics_totals.rerecord(process.cwd(), tree.files)
+async function take_snapshot(
+	phase: ScopedPhase | undefined,
+	snapshot: { tree: GateTree },
+): Promise<void> {
+	if (phase?.script !== scoped_green.LINT_SCRIPT) return
+
+	snapshot.tree = await gate_tree.read_gate_tree()
+}
 
-	return is_rerecorded ? await gate_tree.read_gate_tree() : tree
+async function run_pair_phases(phases: ReadonlyArray<ScopedPhase>): Promise<PairResult> {
+	const snapshot = { tree: await gate_tree.read_gate_tree() }
+	const result = await run_phases(
+		phases.map((phase) => phase.run),
+		async (index) => {
+			await take_snapshot(phases[index], snapshot)
+		},
+	)
+
+	return { ...result, verified: snapshot.tree }
 }
 
 function printed(line: string): JoshResult {
@@ -58,16 +81,19 @@ function printed(line: string): JoshResult {
 }
 
 // Each check bare; every output is kept, so the lap reads each one's fallback reason.
-async function bare_pair(scripts: ReadonlyArray<string>): Promise<JoshResult> {
+async function bare_pair(scripts: ReadonlyArray<string>): Promise<PairResult> {
 	const outs: Array<string> = []
-	const result = await run_phases(
-		scripts.map((script) => async () => {
-			const ran = await josh_command.josh_run([script], should_forward_stderr)
+	const result = await run_pair_phases(
+		scripts.map((script) => ({
+			script,
+			run: async () => {
+				const ran = await josh_command.josh_run([script], should_forward_stderr)
 
-			outs.push(ran.out)
+				outs.push(ran.out)
 
-			return ran
-		}),
+				return ran
+			},
+		})),
 	)
 
 	return { ...result, out: outs.filter((out) => out !== '').join('\n') }
@@ -93,12 +119,11 @@ function check_phases(
 	checks: ReadonlyArray<SyncedCheck>,
 	files: ReadonlyArray<string>,
 	sync: SyncReading | undefined,
-): ReadonlyArray<Phase> {
+): ReadonlyArray<ScopedPhase> {
 	return checks.flatMap((check) =>
-		run_ship_narrowed.named_phases(
-			[check],
-			run_ship_synced_scope.files_for(sync, check.script, files),
-		),
+		run_ship_narrowed
+			.named_phases([check], run_ship_synced_scope.files_for(sync, check.script, files))
+			.map((run) => ({ script: check.script, run })),
 	)
 }
 
@@ -146,10 +171,12 @@ async function narrowed_or_bare(
 	printed(run_ship_narrowed.describe(named.files, named.why))
 
 	const checks = run_ship_synced_scope.checks_of(scripts)
-	const result = await run_phases(check_phases(checks, named.files, sync))
+	const result = await run_pair_phases(check_phases(checks, named.files, sync))
 
-	if (result.code === SUCCESS_EXIT_CODE && (await is_still(tree))) {
-		run_ship_narrowed.record(checks, tree)
+	const verified = result.verified ?? tree
+
+	if (result.code === SUCCESS_EXIT_CODE && (await is_still(verified))) {
+		run_ship_narrowed.record(checks, verified)
 	}
 
 	return { ...result, note: { named: named.files.length } }
@@ -187,8 +214,20 @@ async function stale_pair(tree: GateTree, scripts: ReadonlyArray<string>): Promi
 // base runs nothing when the merge shares nothing with the branch (`run-ship-synced-scope.ts`), and
 // only where the two meet when they do; a pair stale since this ship last met it green on this base
 // runs over what moved since (`run-ship-narrowed.ts`).
+async function remember_result(tree: GateTree, result: PairResult): Promise<PairResult> {
+	const { verified = tree, ...answer } = result
+
+	run_ship_pair_runs.met(verified, result.code, result.out)
+
+	if (result.code === SUCCESS_EXIT_CODE && (await is_still(verified))) {
+		run_ship_narrowed.remember(verified)
+	}
+
+	return answer
+}
+
 async function settled_pair(): Promise<PairResult> {
-	const tree = await rerecorded_tree()
+	const tree = await metrics_totals.rerecorded_tree()
 	const scripts = scoped_green.missing_scripts(tree.files, tree.base)
 
 	// Nothing stale ran nothing, so the records already vouch for the tree read — a ship retried over
@@ -202,10 +241,7 @@ async function settled_pair(): Promise<PairResult> {
 
 	const result = await stale_pair(tree, scripts)
 
-	run_ship_pair_runs.met(tree, result.code, result.out)
-	if (result.code === SUCCESS_EXIT_CODE && (await is_still(tree))) run_ship_narrowed.remember(tree)
-
-	return result
+	return await remember_result(tree, result)
 }
 
 function pair_note({ out, note }: PairResult): LapNote {

package/scripts/run/startup/run-startup-schema.ts

@@ -0,0 +1,31 @@
+import { lane_ledger_kind } from '#scripts/lane/lane-ledger-kind'
+import { z } from 'zod'
+
+const scope_schema = z.object({
+	run: z.string(),
+	attempt: z.string(),
+	issue: z.string().optional(),
+	span: z.string().optional(),
+	parent: z.string().optional(),
+	destination: z.string().optional(),
+})
+
+const entry_schema = scope_schema.omit({ destination: true }).extend({
+	kind: z.literal(lane_ledger_kind.KIND.STARTUP),
+	at: z.string(),
+	at_ms: z.number().nonnegative().optional(),
+	id: z.string(),
+	parent: z.string().optional(),
+	phase: z.string(),
+	edge: z.enum(['start', 'done', 'failed', 'waiting', 'api', 'cache']),
+	elapsed_ms: z.number().nonnegative().optional(),
+	metric: z.string().optional(),
+	key: z.string().optional(),
+})
+
+type StartupScope = z.infer<typeof scope_schema>
+type StartupEntry = z.infer<typeof entry_schema>
+
+const run_startup_schema = { scope_schema, entry_schema }
+export type { StartupScope, StartupEntry }
+export { run_startup_schema }

package/scripts/run/startup/run-startup-store.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { run_carry } from '#scripts/run/carry/run-carry'
+import type { StartupEntry, StartupScope } from './run-startup-schema'
+
+async function carried_identity(issue?: string): Promise<StartupScope | undefined> {
+	const repository = await run_carry.repository_directory()
+	if (repository === undefined) return undefined
+	const read = run_carry.read_carry(run_carry.carry_path(repository))
+	if (read.kind !== 'carried') return undefined
+
+	return {
+		run: `${repository}:${read.carry.started_at}`,
+		attempt: randomUUID(),
+		destination: lane_ledger_write.target_of(repository),
+		...(issue !== undefined && { issue }),
+	}
+}
+
+async function identity(issue?: string): Promise<StartupScope | undefined> {
+	try {
+		if (process.env['VITEST'] !== undefined) return undefined
+
+		return await carried_identity(issue)
+	} catch {
+		return undefined
+	}
+}
+
+async function record(entry: StartupEntry, destination?: string): Promise<void> {
+	await lane_ledger_write.record(entry, destination)
+}
+
+interface StartupSummary {
+	start: StartupEntry
+	status: 'done' | 'failed' | 'waiting' | 'incomplete'
+	elapsed_ms: number | undefined
+	api: Record<string, number>
+	cache: Record<string, number>
+}
+
+function counts(rows: ReadonlyArray<StartupEntry>, edge: 'api' | 'cache'): Record<string, number> {
+	const result: Record<string, number> = {}
+
+	for (const row of rows) {
+		if (row.edge !== edge) continue
+		const key = row.metric ?? 'unknown'
+
+		result[key] = (result[key] ?? 0) + 1
+	}
+
+	return result
+}
+
+function is_terminal(
+	row: StartupEntry,
+): row is StartupEntry & { edge: 'done' | 'failed' | 'waiting' } {
+	return row.edge === 'done' || row.edge === 'failed' || row.edge === 'waiting'
+}
+
+function summary(start: StartupEntry, rows: ReadonlyArray<StartupEntry>): StartupSummary {
+	const ending = rows.find(is_terminal)
+
+	return {
+		start,
+		status: ending?.edge ?? 'incomplete',
+		elapsed_ms: ending?.elapsed_ms,
+		api: counts(rows, 'api'),
+		cache: counts(rows, 'cache'),
+	}
+}
+
+// Direct counts only; parent durations include children and must not be added to them.
+function by_span(entries: ReadonlyArray<StartupEntry>): Map<string, Array<StartupEntry>> {
+	const groups = new Map<string, Array<StartupEntry>>()
+
+	for (const row of entries) {
+		const group = groups.get(row.id) ?? []
+
+		group.push(row)
+		groups.set(row.id, group)
+	}
+
+	return groups
+}
+
+function summarize(entries: ReadonlyArray<StartupEntry>): Array<StartupSummary> {
+	const groups = by_span(entries)
+
+	return entries
+		.filter((row) => row.edge === 'start')
+		.map((start) => summary(start, groups.get(start.id) ?? []))
+}
+
+function timestamp(row: StartupEntry): number {
+	return row.at_ms ?? Date.parse(row.at)
+}
+
+function before_end(
+	row: StartupEntry,
+	other: StartupEntry,
+	endings: ReadonlyMap<string, number>,
+): boolean {
+	const end = endings.get(other.id)
+
+	return end !== undefined && timestamp(row) < end
+}
+
+function overlaps(
+	left: StartupEntry,
+	right: StartupEntry,
+	endings: ReadonlyMap<string, number>,
+): boolean {
+	if (left.id === right.id || left.key !== right.key) return false
+
+	return before_end(left, right, endings) && before_end(right, left, endings)
+}
+
+// A fill is a miss being computed, not a second cache lookup. Overlapping fills on the same hashed
+// key are concurrent misses, including separate processes; no deduplication or lock is introduced.
+function concurrent_misses(entries: ReadonlyArray<StartupEntry>): Array<StartupEntry> {
+	const fills = entries.filter((row) => row.edge === 'cache' && row.metric === 'fill')
+	const endings = new Map(entries.filter(is_terminal).map((row) => [row.id, timestamp(row)]))
+
+	return fills.filter((row) => fills.some((other) => overlaps(row, other, endings)))
+}
+
+const run_startup_store = { identity, record, summarize, concurrent_misses }
+export type { StartupSummary }
+export { run_startup_store }

package/scripts/run/startup/run-startup.ts

@@ -0,0 +1,119 @@
+import { randomUUID } from 'node:crypto'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { lane_ledger_kind } from '#scripts/lane/lane-ledger-kind'
+import { inherited_scope } from '#scripts/lib/inherited-scope'
+import { run_startup_schema, type StartupEntry, type StartupScope } from './run-startup-schema'
+import { run_startup_store } from './run-startup-store'
+
+const ENVIRONMENT_KEY = 'JOSH_STARTUP_SCOPE'
+const scope = inherited_scope.create(ENVIRONMENT_KEY, run_startup_schema.scope_schema)
+
+interface PhaseOptions<T> {
+	issue?: string
+	root?: boolean
+	edge_of?: (value: T) => 'done' | 'failed' | 'waiting'
+}
+
+// A missing or failed measurement never changes the operation's result or error.
+async function record(row: StartupEntry): Promise<void> {
+	try {
+		await run_startup_store.record(row, scope.current()?.destination)
+	} catch {
+		// Reporting is best effort, including test or extension sinks.
+	}
+}
+
+function entry(current: StartupScope, name: string, edge: StartupEntry['edge']): StartupEntry {
+	return run_startup_schema.entry_schema.parse({
+		...current,
+		kind: lane_ledger_kind.KIND.STARTUP,
+		at: new Date().toISOString(),
+		at_ms: performance.timeOrigin + performance.now(),
+		id: current.span ?? randomUUID(),
+		phase: name,
+		edge,
+	})
+}
+
+async function completed<T>(
+	name: string,
+	run: () => Promise<T>,
+	options: PhaseOptions<T>,
+): Promise<T> {
+	const current = scope.current()
+	if (current === undefined) return await run()
+	const started = performance.now()
+
+	await record(entry(current, name, 'start'))
+	const ending: { edge: StartupEntry['edge'] } = { edge: 'failed' }
+
+	try {
+		const value = await run()
+
+		ending.edge = options.edge_of?.(value) ?? 'done'
+
+		return value
+	} finally {
+		await record({ ...entry(current, name, ending.edge), elapsed_ms: performance.now() - started })
+	}
+}
+
+async function current_scope<T>(options: PhaseOptions<T>): Promise<StartupScope | undefined> {
+	return (
+		scope.current() ??
+		(options.root === true ? await run_startup_store.identity(options.issue) : undefined)
+	)
+}
+
+async function phase<T>(
+	name: string,
+	run: () => Promise<T>,
+	options: PhaseOptions<T> = {},
+): Promise<T> {
+	const current = await current_scope(options)
+	if (current === undefined) return await run()
+	const next = {
+		...current,
+		parent: current.span,
+		span: randomUUID(),
+		...(options.issue !== undefined && { issue: options.issue }),
+	}
+
+	return await scope.within(next, async () => await completed(name, run, options))
+}
+
+// Metrics are individual append-only rows, attributed to the innermost span even during parallel work.
+function metric(edge: 'api' | 'cache', name: string, key?: string): void {
+	const current = scope.current()
+	if (current === undefined) return
+	void record({
+		...entry(current, '', edge),
+		metric: name,
+		...(key !== undefined && { key: stamp_file.digest(key) }),
+	})
+}
+
+async function waiting(name: string): Promise<() => Promise<void>> {
+	const current = scope.current()
+	const started = performance.now()
+	const place = { ...current, span: randomUUID(), parent: current?.span }
+	if (current !== undefined) await record(entry({ ...current, ...place }, name, 'start'))
+
+	return async (): Promise<void> => {
+		if (current === undefined) return
+		await record({
+			...entry({ ...current, ...place }, name, 'waiting'),
+			elapsed_ms: performance.now() - started,
+		})
+	}
+}
+
+const run_startup = {
+	ENVIRONMENT_KEY,
+	phase,
+	metric,
+	waiting,
+	environment: scope.environment,
+	within: scope.within,
+}
+export { run_startup }

package/scripts/run/wake/run-wake-codex.ts

@@ -0,0 +1,144 @@
+import { statSync } from 'node:fs'
+import { agent_event, type AgentEventState } from '#scripts/agent/agent-event'
+import type { AgentProfile } from '#scripts/agent/agent-profile-schema'
+import { process_identity } from '#scripts/josh/process-identity'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
+import { run_wake } from './run-wake'
+import type { WakeContext } from './run-wake-describe'
+
+// New launches keep a generation-specific result, so a triage or an older turn cannot finish one.
+function log_path(context: WakeContext, id: string, profile: AgentProfile): string {
+	return profile.provider === 'openai' ? `${context.log_target}.${id}` : context.log_target
+}
+
+function legacy_pid(context: WakeContext, invocation: string): number | undefined {
+	const wake = run_wake.read_wake(context.wake_target)
+	if (wake?.invocation !== invocation) return undefined
+
+	return wake.woke_pid
+}
+
+function execution(context: WakeContext, carry: RunCarry): RunCarry {
+	if (carry.owner_pid !== undefined || carry.owner_session !== undefined) return carry
+
+	return { ...carry, owner_pid: legacy_pid(context, carry.invocation) }
+}
+
+function modified_at(target: string): number {
+	try {
+		return statSync(target).mtimeMs
+	} catch {
+		return 0
+	}
+}
+
+// Legacy logs are shared: only the last launch, written through this wake's mark, can be evidence.
+function launched_at(output: string): number {
+	const header = output.split('\n').findLast((line) => line.startsWith('=== '))
+
+	return Date.parse(header?.slice('=== '.length).split(' · ', 1)[0] ?? '')
+}
+
+function launch_mark(context: WakeContext): number {
+	const wake = run_wake.read_wake(context.wake_target)
+
+	return Date.parse(wake?.woke_at ?? wake?.launch_at ?? '')
+}
+
+function is_legacy_result(context: WakeContext, output: string): boolean {
+	const marked = launch_mark(context)
+	const launched = launched_at(output)
+
+	return (
+		launched <= marked &&
+		marked - launched < run_wake.WAKE_GRACE_MS &&
+		modified_at(context.log_target) >= marked
+	)
+}
+
+function result_of(context: WakeContext, carry: RunCarry): AgentEventState {
+	const target =
+		carry.owner_session === undefined
+			? context.log_target
+			: `${context.log_target}.${carry.owner_session}`
+	const output = stamp_file.read_stamp_text(target) ?? ''
+	const is_usable = carry.owner_session !== undefined || is_legacy_result(context, output)
+
+	return agent_event.read(is_usable ? output : '')
+}
+
+function is_judgment(carry: RunCarry): boolean {
+	return (
+		carry.scheduler_provider === 'openai' &&
+		carry.is_owner_headless === true &&
+		carry.is_handed_off !== true
+	)
+}
+
+function judgment(context: WakeContext): RunCarry | undefined {
+	const read = run_carry.read_carry(context.carry_target)
+
+	return read.kind === 'carried' && is_judgment(read.carry) ? read.carry : undefined
+}
+
+function is_running(carry: RunCarry): boolean {
+	return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false
+}
+
+function hand_back(context: WakeContext, carry: RunCarry): CarryRead {
+	const wake = run_wake.read_wake(context.wake_target)
+	if (wake !== undefined) run_wake.update_wake(context.wake_target, run_wake.count_claim(wake))
+	const next = run_carry.apply_change(context.carry_target, carry, { cuts: 1 })
+
+	run_event_setup.emit_to(context.event_target, run_event_setup.STAGE.HANDING_OFF, new Date())
+
+	return { kind: 'carried', carry: next }
+}
+
+function read_carry(context: WakeContext): CarryRead {
+	const read = run_carry.read_carry(context.carry_target)
+
+	if (read.kind !== 'carried' || !is_judgment(read.carry)) return read
+	const carry = execution(context, read.carry)
+	if (is_running(carry)) return { kind: 'carried', carry }
+	if (result_of(context, carry).result === 'completed') return hand_back(context, read.carry)
+
+	return read
+}
+
+function finished_session(context: WakeContext): string | undefined {
+	const read = read_carry(context)
+	if (read.kind !== 'carried' || read.carry.is_handed_off !== true) return undefined
+
+	return read.carry.owner_session
+}
+
+function refresh(context: WakeContext): void {
+	const session = finished_session(context)
+	if (session === undefined) return
+	const wake = run_wake.read_wake(context.wake_target)
+	if (wake === undefined || wake.spawned?.at(-1) !== session) return
+
+	run_wake.update_wake(context.wake_target, run_wake.count_claim(wake))
+}
+
+function failure_note(result: AgentEventState): string | undefined {
+	return result.result === 'completed'
+		? undefined
+		: `Codex judgment ended without a successful result: ${result.reason ?? result.result}`
+}
+
+function failure(context: WakeContext): string | undefined {
+	const owned = judgment(context)
+	if (owned === undefined) return undefined
+	const carry = execution(context, owned)
+	if (carry.owner_pid === undefined || is_running(carry)) return undefined
+
+	return failure_note(result_of(context, carry))
+}
+
+const run_wake_codex = { failure, log_path, read_carry, refresh }
+
+export { run_wake_codex }