@joshuafolkken/kit 1.3044.0 → 1.3092.0

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 }

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

@@ -1,3 +1,4 @@
+import { backlog_drive_retrospective_unit } from '#scripts/backlog/backlog-drive-retrospective-unit'
 import { epic_triage } from '#scripts/epic/epic-triage'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
@@ -16,6 +17,8 @@ const TRUNCATION_MARK = '... '
 const ERROR_PREFIX = 'error '
 const { WINDOW_MINUTES } = run_wake_window
 const WINDOW_VERDICT = 'window'
+// `backlog-drive.ts`'s drain owing the retrospective.
+const WATCH_VERDICT = 'watch'
 const { TRIAGE_VERDICT } = epic_triage
 
 function driver_args(invocation: string): ReadonlyArray<string> | undefined {
@@ -74,11 +77,24 @@ const NEXT_BY_VERDICT: ReadonlyArray<readonly [string, string]> = [
 const NEXT_DEFAULT = `act on the result by the sections below, ${HAND_BACK}`
 // **A triage session is woken beside the driver, never in its place** (joshuafolkken/kit#7120): the
 // record stays the supervisor's, so the session counts nothing and its turn end hands nothing back.
-const NEXT_BESIDE =
-	"\nNext: the carry record stays the supervisor's, whose driver keeps collecting and filling lanes beside this session, so run no pnpm josh run:carry; act on the result by the sections below, then end the turn"
+const BESIDE =
+	"\nNext: the carry record stays the supervisor's, whose driver keeps collecting and filling lanes beside this session"
+const NEXT_BESIDE = `${BESIDE}, so run no pnpm josh run:carry; act on the result by the sections below, then end the turn`
+
+// **A drain's retrospective runs beside the driver too** (joshuafolkken/kit#7506): handed over, the
+// record left the backlog unread until the session ended and the next pass re-drove, so an issue
+// filed meanwhile waited on the retrospective. Beside it, the driver's re-drive dispatches that issue,
+// and the session's process on the resume line holds the next `watch` back until it has ended
+// (`backlog_drive_park_triage.hand_back`). The record stays this process's, so the close names it.
+const BESIDE_VERDICTS: ReadonlySet<string> = new Set([TRIAGE_VERDICT, WATCH_VERDICT])
 
 function next_move(verdict: string): string {
 	if (verdict === TRIAGE_VERDICT) return NEXT_BESIDE
+
+	if (verdict === WATCH_VERDICT) {
+		return `${BESIDE}. ${backlog_drive_retrospective_unit.brief_of(String(process.pid))} Then end the turn`
+	}
+
 	const found = NEXT_BY_VERDICT.find(([prefix]) => verdict.startsWith(prefix))
 
 	return `\nNext: ${ALREADY_CLAIMED} ${found?.[1] ?? NEXT_DEFAULT}`
@@ -102,7 +118,7 @@ function judged(verdict: string, resume: string, details: string): DriveResult {
 		return { kind: 'failed', note: `backlog:drive returned an invalid resume line: ${resume}` }
 	}
 
-	const kind = verdict === TRIAGE_VERDICT ? 'triage' : 'judgment'
+	const kind = BESIDE_VERDICTS.has(verdict) ? 'triage' : 'judgment'
 
 	return { kind, material: handoff_material(verdict, resume, details) }
 }
@@ -145,13 +161,22 @@ function read_result(result: JoshResult | undefined, target: string): DriveResul
 // **A record this process already owns is claimed again.** A driver that failed leaves the record
 // adopted for the supervisor and not handed off, and the restarted pass re-drives it from here; only a
 // record another live process holds is refused.
+//
+// **A record this process already holds is kept as it is, never rewritten** (joshuafolkken/kit#7506):
+// the adopt removes and re-creates it from this read, so a beside session's `run:carry
+// --retrospective` landing between the two would lose its mark or read no record to close.
+function standing_of(carry: RunCarry): 'adopt' | 'kept' | 'refused' {
+	if (carry.is_handed_off === true) return 'adopt'
+	if (run_carry.is_held_by_self(carry)) return 'kept'
+
+	return run_carry.is_held_by_another(carry) ? 'refused' : 'adopt'
+}
+
 function claim_record(target: string, invocation: string): boolean {
 	const current = run_carry.read_carry(target)
 	if (current.kind !== 'carried' || current.carry.invocation !== invocation) return false
-
-	if (current.carry.is_handed_off !== true && run_carry.is_held_by_another(current.carry)) {
-		return false
-	}
+	const standing = standing_of(current.carry)
+	if (standing !== 'adopt') return standing === 'kept'
 
 	const owner = {
 		...run_carry.owner_of(process.pid),