@joshuafolkken/kit 1.1128.0 → 1.1136.0

package/scripts/issue/issue-state-cli.ts

@@ -188,7 +188,7 @@ function print_states(reports: ReadonlyArray<IssueReport>): void {
 	const should_attribute = reports.length > 1
 	const blocks = reports.flatMap((report) => state_blocks(report, should_attribute))
 
-	issue_report_failures.print_blocks(blocks, BLOCK_SEPARATOR)
+	issue_report_failures.print_blocks(blocks, BLOCK_SEPARATOR, 'issue:state')
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {

package/scripts/josh/josh-commands-lane.ts

@@ -59,7 +59,7 @@ const LANE_COMMANDS: Record<string, CommandEntry> = {
 		description:
 			'Block until any of the named in-flight lane children completes; prints which one finished',
 		category: 'AI tools',
-		reference: ['<issue> [<issue>...]', 'automation', ['processes']],
+		reference: ['<issue> [<issue>...] [--owner <pid>]', 'automation', ['files', 'processes']],
 		default_script_arguments: ['await'],
 	},
 	'lane:launch': {

package/scripts/josh/josh-commands-project.ts

@@ -22,6 +22,13 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 			['files', 'git', 'network', 'processes'],
 		],
 	},
+	'dogfood:commit': {
+		script: 'scripts/dogfood/dogfood-commit-cli.ts',
+		description: "Make the first commit of a dogfood run's own kit-test-* project",
+		category: 'Project',
+		reference: ['<dir>', 'automation', ['files', 'git']],
+		is_kit_only: true,
+	},
 	init: {
 		script: 'scripts/init/init.ts',
 		description: 'Initialize config in a new project',

package/scripts/lane/lane-await.ts

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process'
 import { setTimeout as sleep } from 'node:timers/promises'
+import { parseArgs } from 'node:util'
 import { run_liveness } from '#scripts/run/run-liveness'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_handoff } from './lane-handoff'
@@ -33,6 +34,16 @@ interface AwaitState {
 	is_settled?: boolean
 }
 
+interface AwaitArguments {
+	issues: ReadonlyArray<string>
+	owner: number | undefined
+}
+
+interface RawAwaitArguments {
+	positionals: Array<string>
+	values: { owner?: string | undefined }
+}
+
 // Injectable for testing -- the CLI never overrides these.
 interface AwaitOptions {
 	is_running?: (issue: string) => boolean
@@ -67,6 +78,39 @@ async function is_settled_default(issue: string): Promise<boolean> {
 	return (await run_liveness.read_child_settled(issue)) === true
 }
 
+// An unknown flag or a flag without its value is `undefined`, which is usage.
+function read_await_args(rest: ReadonlyArray<string>): RawAwaitArguments | undefined {
+	try {
+		return parseArgs({
+			args: [...rest],
+			allowPositionals: true,
+			strict: true,
+			options: { owner: { type: 'string' } },
+		})
+	} catch {
+		return undefined
+	}
+}
+
+// Every positional is an issue number, at least one is given, and `--owner` is a pid.
+function is_valid(raw: RawAwaitArguments): boolean {
+	const { owner } = raw.values
+	const numbers = owner === undefined ? raw.positionals : [...raw.positionals, owner]
+
+	return raw.positionals.length > 0 && numbers.every((value) => ISSUE_PATTERN.test(value))
+}
+
+// The issues to wait on and the waiting session's pid, or `undefined` for anything else.
+function parse_arguments(rest: ReadonlyArray<string>): AwaitArguments | undefined {
+	const raw = read_await_args(rest)
+
+	if (raw === undefined || !is_valid(raw)) return undefined
+
+	const { owner } = raw.values
+
+	return { issues: raw.positionals, owner: owner === undefined ? undefined : Number(owner) }
+}
+
 function make_initial_state(is_settled: boolean): AwaitState {
 	return { appeared: false, disappeared_at: undefined, first_polled_at: undefined, is_settled }
 }
@@ -187,13 +231,13 @@ async function wait_for_any(
 }
 
 const lane_await = {
-	ISSUE_PATTERN,
 	NEVER_APPEARED_TIMEOUT_MS,
 	RECONFIRM_MS,
 	check_issue,
 	is_process_running_default,
+	parse_arguments,
 	wait_for_any,
 }
 
-export type { AwaitState, CheckConfig }
+export type { AwaitArguments, AwaitState, CheckConfig }
 export { lane_await }

package/scripts/lane/lane-cli.ts

@@ -6,6 +6,7 @@ import type { OpenIssueData } from '#scripts/git/schemas'
 import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
 import { error_text } from '#scripts/lib/error-message'
 import { run_carry } from '#scripts/run/run-carry'
+import { run_carry_reclaim } from '#scripts/run/run-carry-reclaim'
 import { lane_await } from './lane-await'
 import { lane_close, type CloseOutcome, type SweepOutcome } from './lane-close'
 import { lane_dispatch, type DispatchOutcome } from './lane-dispatch'
@@ -40,7 +41,7 @@ const USAGE = [
 	'       josh lane:prune',
 	'       josh lane:output <issue-number> [<path>]',
 	'       josh lane:dispatch <issue-number>',
-	'       josh lane:await <issue-number> ...',
+	'       josh lane:await <issue-number> ... [--owner <pid>]',
 ].join('\n')
 
 type Handler = (rest: ReadonlyArray<string>) => Promise<number>
@@ -356,22 +357,19 @@ async function dispatch_command(rest: ReadonlyArray<string>): Promise<number> {
 	return await report_dispatch(await lane_dispatch.dispatch_child(issue), issue)
 }
 
-// Each valid argument is an issue number; any non-number stops parsing and triggers usage.
-function parse_issues(rest: ReadonlyArray<string>): ReadonlyArray<string> | undefined {
-	if (rest.length === 0) return undefined
-	const issues = rest.filter((value) => lane_await.ISSUE_PATTERN.test(value))
-
-	return issues.length === rest.length ? issues : undefined
-}
-
 // The completed issue number goes to standard output so `N=$(pnpm josh lane:await ...)` captures
-// which child finished without parsing stderr.
+// which child finished without parsing stderr. `--owner` reclaims the carry record for a resumed
+// conversation before the wait (`run-carry-reclaim.ts`).
 async function await_command(rest: ReadonlyArray<string>): Promise<number> {
-	const issues = parse_issues(rest)
+	const parsed = lane_await.parse_arguments(rest)
 
-	if (issues === undefined) return report_usage()
+	if (parsed === undefined) return report_usage()
+
+	if (parsed.owner !== undefined) {
+		await run_carry_reclaim.reclaim_carry(run_carry.owner_of(parsed.owner))
+	}
 
-	const completed = await lane_await.wait_for_any(issues)
+	const completed = await lane_await.wait_for_any(parsed.issues)
 
 	console.info(completed)
 

package/scripts/release/github-release-environment.ts

@@ -37,6 +37,7 @@ function read_release_input(environment: Environment): ReleaseInput {
 			start_tag: optional(environment['RELEASE_START_TAG']),
 			workflow: optional(environment['RELEASE_WORKFLOW']),
 			jobs: job_names(environment['RELEASE_JOBS']),
+			await_publish: environment['RELEASE_AWAIT_PUBLISH'] === 'true',
 		},
 	}
 }

package/scripts/release/github-release.ts

@@ -15,7 +15,12 @@ const POLL_INTERVAL_MS = 30_000
 const MAX_WAIT_ATTEMPTS = 120
 const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
 const NOTES_SCHEMA = z.object({ name: z.string().min(1), body: z.string().min(1) })
-const RUN_SCHEMA = z.object({ id: z.number(), display_title: z.string() })
+const RUN_SCHEMA = z.object({
+	id: z.number(),
+	display_title: z.string(),
+	status: z.string().optional(),
+	conclusion: z.string().nullable().optional(),
+})
 const JOB_SCHEMA = z.object({
 	name: z.string(),
 	status: z.string(),
@@ -26,15 +31,19 @@ const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
 
 type ReleaseRequest = (url: string, init: RequestInit) => Promise<Response>
 type Wait = () => Promise<void>
+type PollState = 'ready' | 'failed' | 'pending'
 
 // What differs between repositories. `start_tag` is the last tag that predates automatic releases;
 // without it the latest existing release is the floor. `workflow` names the publish workflow whose
 // failed run lets a lower tag be skipped, and `jobs` the jobs in it that count (empty: every job).
+// `await_publish` holds the tag's own release until its run in that workflow has succeeded, for a
+// release started beside the publication rather than from inside it.
 interface ReleaseSettings {
 	repository: string
 	start_tag?: string | undefined
 	workflow?: string | undefined
 	jobs?: ReadonlyArray<string> | undefined
+	await_publish?: boolean | undefined
 }
 
 interface PublishOptions extends ReleaseSettings {
@@ -56,7 +65,14 @@ interface Ladder {
 	tags: ReadonlyArray<string>
 	floor: string | undefined
 	fallback?: () => Promise<string>
+	budget: Budget
+}
+
+// One allowance shared by every wait a release makes: waiting for its own publication and then for
+// lower tags' releases must end inside the job's `timeout-minutes` together, not each on its own.
+interface Budget {
 	wait: Wait
+	remaining: number
 }
 
 function request_options(token: string, method: string, body?: object): RequestInit {
@@ -130,13 +146,22 @@ function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<str
 	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
 }
 
+async function publish_run(
+	client: Client,
+	workflow_name: string,
+	tag: string,
+): Promise<z.infer<typeof RUN_SCHEMA> | undefined> {
+	const workflow = encodeURIComponent(workflow_name)
+	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
+	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
+
+	return runs.find((item) => item.display_title === `Publish ${tag}`)
+}
+
 async function failed_publication(client: Client, tag: string): Promise<boolean> {
 	if (client.workflow === undefined) return false
 
-	const workflow = encodeURIComponent(client.workflow)
-	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
-	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
-	const run = runs.find((item) => item.display_title === `Publish ${tag}`)
+	const run = await publish_run(client, client.workflow, tag)
 	if (!run) return false
 
 	const jobs_response = await api_get(client, `/actions/runs/${String(run.id)}/jobs?per_page=100`)
@@ -149,24 +174,72 @@ async function default_wait(): Promise<void> {
 	await setTimeout(POLL_INTERVAL_MS)
 }
 
-async function release_state(client: Client, tag: string): Promise<'ready' | 'failed' | 'pending'> {
+async function release_state(client: Client, tag: string): Promise<PollState> {
 	if (await existing_release(client, tag)) return 'ready'
 	if (await failed_publication(client, tag)) return 'failed'
 
 	return 'pending'
 }
 
-async function wait_for_release(client: Client, tag: string, wait: Wait): Promise<boolean> {
-	for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt += 1) {
+// A run not listed yet is pending too: the announcement that starts this release also starts the
+// publication, so the release can ask before GitHub has queued that run.
+async function publication_state(
+	client: Client,
+	workflow: string,
+	tag: string,
+): Promise<PollState> {
+	const run = await publish_run(client, workflow, tag)
+	if (run?.status !== 'completed') return 'pending'
+
+	return run.conclusion === 'success' ? 'ready' : 'failed'
+}
+
+async function poll(
+	read: () => Promise<PollState>,
+	budget: Budget,
+	subject: string,
+): Promise<boolean> {
+	while (budget.remaining > 0) {
 		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		const state = await release_state(client, tag)
+		const state = await read()
 		if (state !== 'pending') return state === 'ready'
 
+		budget.remaining -= 1
 		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await wait()
+		await budget.wait()
 	}
 
-	throw new Error(`Timed out waiting for previous GitHub Release ${tag}`)
+	throw new Error(`Timed out waiting for ${subject}`)
+}
+
+async function wait_for_release(client: Client, tag: string, budget: Budget): Promise<boolean> {
+	return await poll(
+		async () => await release_state(client, tag),
+		budget,
+		`previous GitHub Release ${tag}`,
+	)
+}
+
+async function wait_for_publication(client: Client, tag: string, budget: Budget): Promise<boolean> {
+	const { workflow } = client
+	if (workflow === undefined) throw new Error('Waiting for the publication needs RELEASE_WORKFLOW')
+
+	return await poll(
+		async () => await publication_state(client, workflow, tag),
+		budget,
+		`Publish ${tag}`,
+	)
+}
+
+async function is_publication_ready(
+	client: Client,
+	tag: string,
+	options: PublishOptions,
+	budget: Budget,
+): Promise<boolean> {
+	if (options.await_publish !== true) return true
+
+	return await wait_for_publication(client, tag, budget)
 }
 
 async function ladder_end(ladder: Ladder): Promise<string | undefined> {
@@ -184,7 +257,7 @@ async function baseline_tag(
 	if (ladder.floor === undefined) return prior
 	if (!prior) return await ladder_end(ladder)
 
-	return (await wait_for_release(client, prior, ladder.wait))
+	return (await wait_for_release(client, prior, ladder.budget))
 		? prior
 		: await baseline_tag(client, prior, ladder)
 }
@@ -195,16 +268,19 @@ function assert_older(previous: string | undefined, tag: string): void {
 	}
 }
 
-async function build_ladder(client: Client, options: PublishOptions): Promise<Ladder> {
+async function build_ladder(
+	client: Client,
+	options: PublishOptions,
+	budget: Budget,
+): Promise<Ladder> {
 	const tags = options.tags ?? []
-	const wait = options.wait ?? default_wait
 	const { start_tag } = options
 
 	if (start_tag !== undefined) {
-		return { tags, wait, floor: start_tag, fallback: async () => await previous_tag(client) }
+		return { tags, budget, floor: start_tag, fallback: async () => await previous_tag(client) }
 	}
 
-	return { tags, wait, floor: await latest_release(client) }
+	return { tags, budget, floor: await latest_release(client) }
 }
 
 async function generate_notes(
@@ -252,6 +328,10 @@ function create_client(request: ReleaseRequest, token: string, settings: Release
 	}
 }
 
+function create_budget(options: PublishOptions): Budget {
+	return { wait: options.wait ?? default_wait, remaining: MAX_WAIT_ATTEMPTS }
+}
+
 async function publish(
 	request: ReleaseRequest,
 	token: string,
@@ -263,7 +343,13 @@ async function publish(
 	const client = create_client(request, token, options)
 	if (await existing_release(client, tag)) return 'already-published'
 
-	const previous = await baseline_tag(client, tag, await build_ladder(client, options))
+	const budget = create_budget(options)
+
+	if (!(await is_publication_ready(client, tag, options, budget))) {
+		return `skipped ${tag}: Publish ${tag} did not succeed`
+	}
+
+	const previous = await baseline_tag(client, tag, await build_ladder(client, options, budget))
 
 	assert_older(previous, tag)
 	await create_release(client, tag, previous)

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

@@ -10,6 +10,7 @@ import {
 	type RunCarry,
 } from './run-carry'
 import { run_carry_args, type CountRequest, type Request } from './run-carry-args'
+import { run_carry_conversation } from './run-carry-conversation'
 import { run_carry_stash } from './run-carry-stash'
 import { run_event_stream } from './run-event-stream'
 import { run_event_stream_emit } from './run-event-stream-emit'
@@ -331,7 +332,8 @@ async function count(
 
 	if (blocked !== undefined) return blocked
 
-	const carry = run_carry.apply_change(target, read.carry, request.change)
+	const owned = run_carry_conversation.reclaim_owner(read.carry, request.owner)
+	const carry = run_carry.apply_change(target, owned, request.change)
 
 	await record_retrospective(request)
 

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

@@ -0,0 +1,94 @@
+import { existsSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
+import { own_session } from '#scripts/cost-runtime/own-session'
+import type { CarryOwner, RunCarry } from './run-carry'
+
+// **A conversation outlives its process, so an owner named by a pid alone dies too early**
+// (joshuafolkken/kit#3137). The carry record names the agent process spending the budget, and that is
+// right while the process lives — but an interactive conversation is not its process. On 2026-10-04 a
+// VS Code extension-host restart ended the session's process at 15:17:34 UTC, and the same
+// conversation resumed eighteen seconds later in a new process (`--resume=<id>`), writing on into the
+// same transcript. `run:wake` read the old pid as dead, recovered the record as a crash, and dispatched
+// a second lane child for the issue the conversation was still running.
+//
+// **The transcript is what persists across the restart, so it is the second half of the identity.**
+// Every resume path — the extension's `--resume=<id>`, a person's `claude -c` — appends to the one
+// file named by the session id, and nothing else writes it. So a record also names its owner's
+// transcript, and a dead pid whose transcript was written inside the quiet window below is a
+// conversation still being continued rather than a crash. Matching the transcript is also how the
+// resumed conversation is recognized as the record's own owner, so it can keep counting.
+//
+// **A hand-off ends the conversation's claim.** A record `--cut` handed off is waited on by the pid
+// alone, because the cutting conversation is meant to end there — counted by its transcript, the
+// supervisor would hold every cut for the whole window after the cutting process had already exited.
+
+// How long after its last write a conversation whose process has gone still counts as continuing. It
+// bridges a restart and a resume — measured at eighteen seconds — with room for a person reopening a
+// window, and it is the order of the wake grace window, so a genuine crash is recovered no later than
+// a lost wake would be retried.
+const CONVERSATION_QUIET_MS = 600_000
+
+type Environment = Readonly<Record<string, string | undefined>>
+
+// The calling session's own transcript, or `undefined` outside a session or when its file cannot be
+// found. **The id comes from the environment, which a detached supervisor never inherits**
+// (`agent-session-environment.ts` strips it), so a record the supervisor adopts names no transcript.
+function own_transcript(
+	environment: Environment = process.env,
+	directories: ReadonlyArray<string> = cost_transcript.transcript_directories(process.cwd()),
+): string | undefined {
+	const session_id = own_session.session_id_of(environment)
+
+	if (session_id === undefined) return undefined
+
+	const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`
+
+	return directories.map((directory) => path.join(directory, name)).find((file) => existsSync(file))
+}
+
+function modified_ms(transcript: string): number | undefined {
+	try {
+		return statSync(transcript).mtimeMs
+	} catch {
+		return undefined
+	}
+}
+
+function is_recent(modified: number | undefined, now: Date): boolean {
+	return modified !== undefined && now.getTime() - modified <= CONVERSATION_QUIET_MS
+}
+
+function is_conversation_live(
+	carry: RunCarry,
+	now: Date = new Date(),
+	read_modified: (transcript: string) => number | undefined = modified_ms,
+): boolean {
+	if (carry.is_handed_off === true || carry.owner_transcript === undefined) return false
+
+	return is_recent(read_modified(carry.owner_transcript), now)
+}
+
+function is_same_conversation(carry: RunCarry, owner: CarryOwner): boolean {
+	return owner.transcript !== undefined && owner.transcript === carry.owner_transcript
+}
+
+// The record with its owner moved to the caller's process when the caller is the same conversation in
+// a new one, so the record goes on naming a live process once the conversation falls quiet. A record a
+// cut handed off is the successor's to take, never the cutting conversation's to take back.
+function reclaim_owner(carry: RunCarry, owner: CarryOwner): RunCarry {
+	if (carry.is_handed_off === true || !is_same_conversation(carry, owner)) return carry
+	if (owner.pid === carry.owner_pid) return carry
+
+	return { ...carry, owner_pid: owner.pid, owner_start: owner.start }
+}
+
+const run_carry_conversation = {
+	CONVERSATION_QUIET_MS,
+	own_transcript,
+	is_conversation_live,
+	is_same_conversation,
+	reclaim_owner,
+}
+
+export { run_carry_conversation }

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

@@ -0,0 +1,37 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { run_carry, type CarryOwner } from './run-carry'
+import { run_carry_conversation } from './run-carry-conversation'
+
+// **A resumed conversation has to take its record back before it falls quiet** (joshuafolkken/kit#3137).
+// A count moves the owner to the conversation's new process, but a parent waiting on a lane child
+// counts nothing — `lane:await` blocks in the background and the transcript stays unwritten — so a
+// restart followed by a long wait outlasts the quiet window with the record still naming the dead
+// process, and `run:wake` recovers it as a crash. The wait itself is therefore where the parent
+// declares its owner: `lane:await --owner "$PPID"` reclaims the record before it starts waiting.
+
+// Writes the record back under the caller's process when the caller is the record's own conversation
+// in a new one; answers whether it did.
+function reclaim_at(target: string, owner: CarryOwner): boolean {
+	const read = run_carry.read_carry(target)
+
+	if (read.kind !== 'carried') return false
+
+	const reclaimed = run_carry_conversation.reclaim_owner(read.carry, owner)
+
+	if (reclaimed === read.carry) return false
+
+	// Replaced atomically: a `run:wake` reading between an unlink and a write would see no record.
+	stamp_file.replace_stamp(target, reclaimed)
+
+	return true
+}
+
+async function reclaim_carry(owner: CarryOwner): Promise<boolean> {
+	const directory = await run_carry.repository_directory()
+
+	return directory !== undefined && reclaim_at(run_carry.carry_path(directory), owner)
+}
+
+const run_carry_reclaim = { reclaim_at, reclaim_carry }
+
+export { run_carry_reclaim }

package/scripts/run/run-carry.ts

@@ -4,6 +4,7 @@ import { process_identity } from '#scripts/josh/process-identity'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { z } from 'zod'
 import { run_carry_change } from './run-carry-change'
+import { run_carry_conversation } from './run-carry-conversation'
 import { run_invocation } from './run-invocation'
 
 // joshuafolkken/kit#1714: a `backlogrun` declares a budget — `--max`, `--idle` and the 8-hour
@@ -106,6 +107,9 @@ interface RunCarry {
 	// them apart would be asserting a distinction nothing here can observe.
 	owner_pid?: number | undefined
 	owner_start?: string | undefined
+	// The owner conversation's transcript, which outlives a restart of its process
+	// (`run-carry-conversation.ts`, joshuafolkken/kit#3137). Optional for the same reason as the pid.
+	owner_transcript?: string | undefined
 	// Set by `--cut`, and by nothing else. A crash never reaches `--cut`, which is what makes a
 	// declared cut the only standing record carried without a person deciding.
 	is_handed_off?: boolean | undefined
@@ -129,10 +133,12 @@ interface RunCarry {
 }
 
 // The identity of a process, as `process-identity.ts` keeps it: the pid plus an opaque start-time
-// token, so a reissued pid is never mistaken for the process that wrote the record.
+// token, so a reissued pid is never mistaken for the process that wrote the record — and the
+// transcript of the conversation that process runs, which outlives it (`run-carry-conversation.ts`).
 interface CarryOwner {
 	pid?: number | undefined
 	start?: string | undefined
+	transcript?: string | undefined
 }
 
 // **`resume` is the only one of the four that establishes anything.** The other three are refusals,
@@ -201,6 +207,7 @@ const run_carry_schema = z.object({
 	// which is the not-provably-live answer rather than a live one.
 	owner_pid: z.number().optional(),
 	owner_start: z.string().optional(),
+	owner_transcript: z.string().optional(),
 	is_handed_off: z.boolean().optional(),
 	done: z.array(z.number()).optional(),
 	// Optional, so a record written before the retrospective existed still parses (joshuafolkken/kit#2328).
@@ -256,12 +263,14 @@ function read_carry(target: string, now: Date = new Date()): CarryRead {
 
 // The identity to record for a pid the caller declared. `read_start` is what makes the pair an
 // identity rather than a number; injected in tests so the sandbox branch is exercised without
-// changing the machine's process capabilities.
+// changing the machine's process capabilities. The transcript is the calling session's own — the
+// declared pid is that session's process (`--owner "$PPID"`).
 function owner_of(
 	pid: number,
 	read: (owner_pid: number) => string | undefined = process_identity.read_start,
+	transcript: string | undefined = run_carry_conversation.own_transcript(),
 ): CarryOwner {
-	return { pid, start: read(pid) }
+	return { pid, start: read(pid), transcript }
 }
 
 function fresh_carry(invocation: string, owner: CarryOwner, now: Date): RunCarry {
@@ -275,6 +284,7 @@ function fresh_carry(invocation: string, owner: CarryOwner, now: Date): RunCarry
 		outages: NO_INCREMENT,
 		owner_pid: owner.pid,
 		owner_start: owner.start,
+		owner_transcript: owner.transcript,
 	}
 }
 
@@ -329,6 +339,7 @@ function adopt_carry(
 		...carry,
 		owner_pid: owner.pid,
 		owner_start: owner.start,
+		owner_transcript: owner.transcript,
 		is_handed_off: false,
 	}
 
@@ -340,11 +351,16 @@ function adopt_carry(
 // A live pid with no readable start token is conservatively held rather than replaced. The command
 // cannot prove its generation inside that sandbox, but a false `busy` stops for a person while a
 // false `standing` can put two parents on one budget. A record with no pid still resolves false.
-function is_owner_live(carry: RunCarry): boolean {
-	return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false
+// A gone process whose conversation is still being continued is live (`run-carry-conversation.ts`).
+function is_owner_live(carry: RunCarry, now: Date = new Date()): boolean {
+	if (process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false) return true
+
+	return run_carry_conversation.is_conversation_live(carry, now)
 }
 
 function is_owned_by(carry: RunCarry, owner: CarryOwner): boolean {
+	if (run_carry_conversation.is_same_conversation(carry, owner)) return true
+
 	return carry.owner_pid === owner.pid && carry.owner_start === owner.start
 }
 

package/scripts/run/run-merge-steps.ts

@@ -10,6 +10,7 @@ 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 { run_merge } from './run-merge'
 
@@ -105,7 +106,9 @@ async function apply_carry(
 		return { kind: 'refused', carry: record.carry }
 	}
 
-	return { kind: 'applied', carry: run_carry.apply_change(record.target, record.carry, change) }
+	const owned = run_carry_conversation.reclaim_owner(record.carry, ctx.owner)
+
+	return { kind: 'applied', carry: run_carry.apply_change(record.target, owned, change) }
 }
 
 // The carry record when this session may not act on it — the same ownership guard `apply_carry` asks —

package/scripts/test/test-related.ts

@@ -26,12 +26,7 @@ import { test_unit_guard } from './test-unit-guard'
 function conclusive_tree(before: GateTree | undefined): GateTree | undefined {
 	if (before === undefined) return undefined
 
-	const action = test_unit_guard.resolve_guard_action(
-		test_unit_guard.is_vitest_installed(process.cwd()),
-		test_unit_guard.has_unit_tests(process.cwd()),
-	)
-
-	return action === 'run' ? before : undefined
+	return test_unit_guard.guard_action(process.cwd()) === 'run' ? before : undefined
 }
 
 async function run_related_tests(command_arguments: ReadonlyArray<string>): Promise<number> {