@joshuafolkken/kit 1.3041.0 → 1.3092.0

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),

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

@@ -19,10 +19,7 @@ import { run_carry_reclaim } from '#scripts/run/carry/run-carry-reclaim'
 // The adoption also recovers a record whose owner died without a cut (`run-wake.ts` →
 // `decide_not_handed_off`): it rewrites the owner and clears any hand-off, whoever held it.
 //
-// **A Codex session cannot be given its session id** (`agent-argv.ts` → `build`), so neither its
-// transcript nor its pid is known here: it is adopted with the pid-less owner `run:carry --resume`
-// writes for it, and its pid is never moved onto the record — a pid it cannot match would make its
-// own counts a foreign live owner's.
+// Codex authenticates with a launch identity; the launched PID supplies liveness independently.
 //
 // `hand_off` is the older recovery the backlog preflight still runs: it marks the record handed off,
 // as a `--cut` does, so a later claim over it reads `resume` rather than `standing`.
@@ -34,7 +31,9 @@ interface WakeSession {
 }
 
 function session_owner(session: WakeSession): CarryOwner {
-	if (session.provider === agent_provider.OPENAI_PROVIDER) return { is_headless: true }
+	if (session.provider === agent_provider.OPENAI_PROVIDER) {
+		return { session: session.session_id, is_headless: true }
+	}
 
 	const directory = cost_transcript.transcript_directory(session.worktree)
 	const transcript = run_carry_conversation.transcript_of(session.session_id, directory)
@@ -60,11 +59,13 @@ function hand_to(target: string, owner: CarryOwner): void {
 	run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider })
 }
 
-// Through `reclaim_at`, so the transcript the adoption named is what lets the pid move — one writer.
+// Through the shared reclaim writer, authenticated by transcript or launch identity.
 function hand_on(target: string, owner: CarryOwner, pid: number): void {
-	if (owner.transcript === undefined) return
+	if (owner.transcript === undefined && owner.session === undefined) return
 
-	run_carry_reclaim.reclaim_at(target, run_carry.owner_of(pid, undefined, owner.transcript))
+	const process_owner = run_carry.owner_of(pid, undefined, owner.transcript)
+
+	run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session })
 }
 
 // **The launched pid is the supervisor's own write, so it is no sign the session picked the run up**:

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

@@ -30,6 +30,8 @@ const STOPPED_BY_PERSON: LoopStop = { reason: STOPPED_REASON, note: undefined }
 const CODE_CHANGED: LoopStop = { reason: RELOAD_REASON, note: undefined }
 
 interface LoopPorts {
+	refresh?: () => void
+	session_failure?: () => string | undefined
 	// The carry record, re-read every pass rather than cached: it is written by the parent loop of a
 	// different session, which is the whole point of reading it here.
 	read_carry: () => CarryRead
@@ -200,14 +202,25 @@ async function retry_closes(ports: LoopPorts): Promise<void> {
 // stopping any lane. A record already removed ends the loop before this pass is reached, and a carry
 // record that ended or became unreadable stops the run before the code is checked, so a reload never
 // hands a finished run to a successor.
+async function preflight_stop(
+	decision: WakeDecision,
+	ports: LoopPorts,
+): Promise<LoopStop | undefined> {
+	if (decision.kind === 'stop') return undefined
+	const failure = ports.session_failure?.()
+	if (failure !== undefined) return { reason: FAILED_REASON, note: failure }
+
+	return (await ports.is_code_stale()) ? CODE_CHANGED : undefined
+}
+
 async function run_pass(
 	target: string,
 	wake: RunWake,
 	ports: LoopPorts,
 ): Promise<LoopStop | undefined> {
 	const decision = await decide_pass(wake, ports)
-
-	if (decision.kind !== 'stop' && (await ports.is_code_stale())) return CODE_CHANGED
+	const stop = await preflight_stop(decision, ports)
+	if (stop !== undefined) return stop
 
 	await retry_closes(ports)
 
@@ -254,12 +267,19 @@ function without_release_gap(ports: LoopPorts): LoopPorts {
 	}
 }
 
+function refreshed_wake(target: string, ports: LoopPorts): RunWake | undefined {
+	if (run_wake.read_own_wake(target) === undefined) return undefined
+	ports.refresh?.()
+
+	return run_wake.read_own_wake(target)
+}
+
 async function run_loop(target: string, ports: LoopPorts, interval_ms: number): Promise<LoopStop> {
 	const continuous = without_release_gap(ports)
 
 	return await poll.wait_for(
 		async () => {
-			const wake = run_wake.read_own_wake(target)
+			const wake = refreshed_wake(target, continuous)
 
 			return wake === undefined ? STOPPED_BY_PERSON : await run_pass(target, wake, continuous)
 		},

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

@@ -5,8 +5,10 @@ import { lane_close } from '#scripts/lane/lane-close'
 import { lane_withdraw_closed } from '#scripts/lane/lane-withdraw-closed'
 import { poll } from '#scripts/lib/poll'
 import { run_carry, type CarryOwner, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_carry_session } from '#scripts/run/carry/run-carry-session'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_headless } from '#scripts/run/run-headless'
+import { run_wake_codex } from './run-wake-codex'
 import type { WakeContext } from './run-wake-describe'
 import { run_wake_driver } from './run-wake-driver'
 import { run_wake_handoff } from './run-wake-handoff'
@@ -66,7 +68,12 @@ function launch_session(
 	if (built === undefined) return { kind: 'failed', note: UNSAFE_INVOCATION_NOTE }
 	if (built.kind === 'rejected') return { kind: 'failed', note: built.note }
 
-	const target = { cwd: context.worktree, env: session.environment, log_path: context.log_target }
+	const target = {
+		cwd: context.worktree,
+		env: session.environment,
+		log_path: run_wake_codex.log_path(context, session.id, profile),
+	}
+	if (profile.provider === 'openai') note_to_stderr(`session output: ${target.log_path}`)
 
 	return run_wake_session.launch({ argv: built.argv, ...target, profile }, note_to_stderr)
 }
@@ -136,7 +143,10 @@ function session_ports(context: WakeContext, profile: AgentProfile): SessionPort
 			wake_session(context, invocation, profile, {
 				id: session_id,
 				material,
-				environment: run_headless.environment(),
+				environment:
+					profile.provider === 'openai'
+						? { ...run_headless.environment(), [run_carry_session.KEY]: session_id }
+						: run_headless.environment(),
 			}),
 		wake_beside: (invocation, session_id, material) =>
 			wake_beside(context, invocation, profile, {
@@ -164,7 +174,11 @@ function ports_for(
 
 	return {
 		is_code_stale,
-		read_carry: () => run_carry.read_carry(context.carry_target),
+		refresh: () => {
+			run_wake_codex.refresh(context)
+		},
+		session_failure: () => run_wake_codex.failure(context),
+		read_carry: () => run_wake_codex.read_carry(context),
 		is_owner_live: (read) => read.kind === 'carried' && is_session_at_work(read.carry),
 		has_work: async () => true,
 		...session_ports(context, profile),

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

@@ -1,3 +1,4 @@
+import { backlog_dispatch_bound } from '#scripts/backlog/backlog-dispatch-bound'
 import { process_identity } from '#scripts/josh/process-identity'
 import { poll } from '#scripts/lib/poll'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
@@ -13,8 +14,10 @@ import { run_wake_stop } from './run-wake-stop'
 // bound, is a reload that failed.
 
 const TAKEOVER_INTERVAL_MS = MS_PER_SECOND
-// A cold `tsx` start claims within seconds; the bound is generous so a loaded machine is not a failure.
-const TAKEOVER_ATTEMPTS = 120
+// A cold `tsx` start claims within seconds. The successor still has a driver to start after its claim,
+// so the claim gets what the dispatch bound leaves after that start (joshuafolkken/kit#7507).
+const TAKEOVER_WAIT_MS = backlog_dispatch_bound.NOTICE_MS
+const TAKEOVER_ATTEMPTS = TAKEOVER_WAIT_MS / TAKEOVER_INTERVAL_MS
 
 type TakeoverResult = 'taken' | 'died' | 'unclaimed'
 
@@ -60,7 +63,7 @@ async function await_takeover(
 	return result
 }
 
-const run_wake_takeover = { await_takeover, ports_of }
+const run_wake_takeover = { TAKEOVER_WAIT_MS, await_takeover, ports_of }
 
 export type { TakeoverPorts, TakeoverResult }
 export { run_wake_takeover }

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

@@ -1,3 +1,4 @@
+import { backlog_dispatch_bound } from '#scripts/backlog/backlog-dispatch-bound'
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 
 // **The driver is bounded so the supervisor reaches its pass boundary between dispatches**
@@ -10,6 +11,8 @@ const WINDOW_MS = WINDOW_MINUTES * MS_PER_MINUTE
 // **The supervisor's pause between passes is its own, not the driver's offer interval**
 // (joshuafolkken/kit#6718): a pass reads local records, and the backlog only through the driver, so
 // stretching the offer interval for the REST budget must not slow how soon a judgment hand-off is seen.
-const PASS_INTERVAL_MS = MS_PER_MINUTE
+// A pass may start a fresh driver, so the pause is what the dispatch bound leaves after that start
+// (joshuafolkken/kit#7507).
+const PASS_INTERVAL_MS = backlog_dispatch_bound.NOTICE_MS
 
 export const run_wake_window = { WINDOW_MINUTES, WINDOW_MS, PASS_INTERVAL_MS }

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

@@ -45,6 +45,8 @@ interface RunWake {
 	woke: number
 	// The grace window is measured from this; cleared when the woken session claims the record.
 	woke_at?: string | undefined
+	// Kept after claim so legacy shared-log completion can authenticate the launch.
+	launch_at?: string | undefined
 	// Launches for the current cut: what was started, against `woke`'s what arrived.
 	attempts?: number | undefined
 	// Named in the failure warning, never killed — a slow session is still doing the run's work.
@@ -100,6 +102,7 @@ const run_wake_schema = process_owner_schema.extend({
 	started_at: z.string(),
 	woke: z.number(),
 	woke_at: z.string().optional(),
+	launch_at: z.string().optional(),
 	// Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
 	attempts: z.number().optional(),
 	woke_pid: z.number().optional(),
@@ -199,6 +202,7 @@ function carried_state(existing: RunWake | undefined, invocation: string): Parti
 	return {
 		woke: existing.woke,
 		woke_at: existing.woke_at,
+		launch_at: existing.launch_at,
 		attempts: existing.attempts,
 		woke_pid: existing.woke_pid,
 		spawned: existing.spawned,
@@ -266,6 +270,7 @@ function count_claim(wake: RunWake): RunWake {
 	return {
 		...wake,
 		woke,
+		launch_at: wake.woke_at ?? wake.launch_at,
 		woke_at: undefined,
 		attempts: undefined,
 		idle_since: undefined,

package/scripts/sync/sync-ai-files.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
+import { is_workflow_destination } from '#scripts/claude/workflow-destination'
 import { init_ai_copy } from '#scripts/init/init-ai-copy'
 import { transform_copied_content } from '#scripts/init/init-copy-content'
 import { init_logic } from '#scripts/init/init-logic'
@@ -7,7 +8,9 @@ import { PACKAGE_DIR, PROJECT_ROOT } from '#scripts/init/init-paths'
 import type { ProjectShape } from '#scripts/init/project-profile'
 import { security_policy } from '#scripts/init/security-policy'
 import { file_reader } from '#scripts/lib/read-file'
+import { managed_marker_logic } from '#scripts/managed-marker/managed-marker-logic'
 import { pack_hook } from '#scripts/safe-chain/pack-hook'
+import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { claude_settings_merge } from './claude-settings-merge'
 import { copy_directory_failure, directory_copy_blocker } from './directory-copy-guard'
 import { file_content } from './file-content'
@@ -20,7 +23,21 @@ const CLAUDE_MD_FILENAME = 'CLAUDE.md'
 const CLAUDE_SETTINGS_FILE = '.claude/settings.json'
 const CODEX_HOOKS_FILE = '.codex/hooks.json'
 
+function keep_custom_workflow(destination: string): boolean {
+	if (!is_workflow_destination(destination)) return false
+	const existing = file_reader.read_optional(destination)
+	if (existing === undefined) return false
+	const marker = `${managed_marker_logic.MARKER_PREFIX} ${KIT_PACKAGE_NAME}`
+	if (existing.split(/\r?\n/u, 1)[0] === marker) return false
+	console.warn(
+		`  ⚠ kept      ${destination} (custom workflow; migrate its acquisition settings manually)`,
+	)
+
+	return true
+}
+
 function sync_ai_file(source_path: string, destination_path: string): boolean {
+	if (keep_custom_workflow(destination_path)) return false
 	const content = readFileSync(source_path, 'utf8')
 
 	return file_content.write_text_if_changed(

package/scripts/sync/sync-configs.ts

@@ -35,7 +35,17 @@ function sync_with_merge(
 // lines, including env-var forms: npmrcAuthFile can opt the file into authentication from a deploy
 // dashboard that sync cannot inspect.
 function sync_npmrc(destination_path: string): void {
-	sync_with_merge(destination_path, '.npmrc', init_logic.merge_npmrc)
+	const existing = existsSync(destination_path) ? readFileSync(destination_path, 'utf8') : ''
+	const merged = init_logic.merge_npmrc(existing, path.dirname(destination_path))
+
+	if (merged === existing) {
+		console.info('  ✔ unchanged .npmrc')
+
+		return
+	}
+
+	file_content.write_contained(destination_path, merged)
+	console.info('  ✔ synced    .npmrc')
 }
 
 // Union-merge kit's .gitignore entries into the consumer file instead of overwriting it,

package/scripts/sync/sync.ts

@@ -194,7 +194,11 @@ function sync_consumer_resolved_development_deps(destination_path: string): void
 function sync_prepare_lefthook_warning(destination_path: string): void {
 	sync_package_json_with(
 		destination_path,
-		(existing) => init_logic.upgrade_prepare_lefthook_warning(existing),
+		(existing) =>
+			init_logic.upgrade_npm_lifecycle(
+				init_logic.upgrade_prepare_lefthook_warning(existing),
+				path.dirname(destination_path),
+			),
 		'  ✔ synced    prepare lefthook install warning (run `pnpm install`)',
 	)
 }

package/scripts/test/test-related-cap.ts

@@ -4,11 +4,12 @@ import { direct_importers } from './direct-importers'
 import { test_declared_logic } from './test-declared-logic'
 import { test_pinned_logic } from './test-pinned-logic'
 import { test_pinned_reach, type ReachedCount } from './test-pinned-reach'
+import { test_related_imports } from './test-related-imports'
 import { test_related_pins } from './test-related-pins'
 import { related_scope } from './test-related-scope'
 
 // **A change whose imports reach more than `test_pinned_logic.MAX_TEST_FILES` test files runs only the
-// tests importing its widest files directly** (joshuafolkken/kit#5532, #5702), as a file every test imports does
+// tests importing its widest files directly when their imports are unchanged** (#7453, #5532, #5702), as a file every test imports does
 // (`direct-importers.ts`): the tests past them stay unchecked here, for `josh gate`'s whole suite and
 // CI to run. `--keep-whole-suite` (the gate's unit leg) lifts the cap outside a lane
 // (`test-related-whole.ts`), and so does a missing graph.
@@ -85,7 +86,8 @@ async function direct_of(
 	root: string,
 	over_cap: ReadonlyArray<string>,
 ): Promise<Array<[string, Array<string>]>> {
-	const importers = await direct_importers.importers_of(root, over_cap)
+	const stable = await test_related_imports.stable_files(root, over_cap)
+	const importers = await direct_importers.importers_of(root, stable)
 	const narrowed = [...importers].filter(([, tests]) => tests.length > 0)
 
 	return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)])
@@ -96,7 +98,9 @@ async function split_of(
 	root: string,
 	files: ReadonlyArray<string>,
 ): Promise<[Map<string, Array<string>>, Array<string>]> {
-	const every_test = await direct_importers.every_test_importers(root, files)
+	const shared = direct_importers.every_test_imports_of(files)
+	const stable = await test_related_imports.stable_files(root, shared)
+	const every_test = await direct_importers.every_test_importers(root, stable)
 
 	return [every_test, candidates_of(root, files, every_test)]
 }