@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/runtime-mcp/transports/stdio.ts

@@ -24,6 +24,12 @@ import { MCPExpectedFailure, toJsonRpcError } from "../../runtime-mcp/types";
  */
 const CLOSE_WAIT_MS = 1_000;
 
+/** Write one JSONL frame while honoring Bun FileSink backpressure and flush failures. */
+export async function writeStdioFrame(stdin: Bun.FileSink, message: string): Promise<void> {
+	await Promise.resolve(stdin.write(message));
+	await stdin.flush();
+}
+
 /**
  * Build a minimal environment for a no-inherit stdio MCP child. Only OS-level
  * keys needed to locate/run an interpreter (PATH, HOME, temp, locale, and the
@@ -69,6 +75,9 @@ export class StdioTransport implements MCPTransport {
 	#readLoop: Promise<void> | null = null;
 	#stderrLoop: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
+	#writeQueue: Promise<void> = Promise.resolve();
+	#connectionEpoch = 0;
+	#terminalFailure: { epoch: number; error: MCPExpectedFailure } | undefined;
 
 	onClose?: () => void;
 	onError?: (error: Error) => void;
@@ -115,6 +124,8 @@ export class StdioTransport implements MCPTransport {
 			throw new MCPExpectedFailure(error);
 		}
 
+		this.#connectionEpoch++;
+		this.#terminalFailure = undefined;
 		this.#connected = true;
 
 		// Start reading stdout
@@ -126,6 +137,7 @@ export class StdioTransport implements MCPTransport {
 
 	async #startReadLoop(): Promise<void> {
 		if (!this.#process?.child.stdout) return;
+		const epoch = this.#connectionEpoch;
 		let failure: MCPExpectedFailure | undefined;
 		try {
 			for await (const line of readJsonl(this.#process.child.stdout)) {
@@ -138,11 +150,12 @@ export class StdioTransport implements MCPTransport {
 			}
 		} catch (error) {
 			failure = new MCPExpectedFailure(error);
-			if (this.#connected) {
-				this.onError?.(failure);
-			}
 		} finally {
-			this.#handleClose(failure);
+			if (failure) {
+				this.#terminalizeFailure(failure, epoch);
+			} else {
+				this.#handleClose();
+			}
 		}
 	}
 
@@ -177,7 +190,10 @@ export class StdioTransport implements MCPTransport {
 		}
 		// Server-to-client request: has both method and id
 		if ("method" in message && "id" in message && message.id != null) {
-			void this.#handleServerRequest(message as JsonRpcRequest);
+			const stdin = this.#getStdin();
+			if (stdin) {
+				void this.#handleServerRequest(message as JsonRpcRequest, this.#connectionEpoch, stdin);
+			}
 			return;
 		}
 
@@ -211,21 +227,23 @@ export class StdioTransport implements MCPTransport {
 		}
 	}
 
-	async #handleServerRequest(request: JsonRpcRequest): Promise<void> {
+	async #handleServerRequest(request: JsonRpcRequest, epoch: number, stdin: Bun.FileSink): Promise<void> {
+		if (!this.onRequest) {
+			await this.#sendResponseOrClose(request.id, epoch, stdin, undefined, {
+				code: -32601,
+				message: "Method not found",
+			});
+			return;
+		}
+
+		let result: unknown;
 		try {
-			if (!this.onRequest) {
-				this.#sendResponse(request.id, undefined, { code: -32601, message: "Method not found" });
-				return;
-			}
-			const result = await this.onRequest(request.method, request.params);
-			this.#sendResponse(request.id, result);
+			result = await this.onRequest(request.method, request.params);
 		} catch (error) {
-			try {
-				this.#sendResponse(request.id, undefined, toJsonRpcError(error));
-			} catch {
-				// Best-effort — process may have exited
-			}
+			await this.#sendResponseOrClose(request.id, epoch, stdin, undefined, toJsonRpcError(error));
+			return;
 		}
+		await this.#sendResponseOrClose(request.id, epoch, stdin, result);
 	}
 
 	#getStdin(): Bun.FileSink | null {
@@ -233,28 +251,70 @@ export class StdioTransport implements MCPTransport {
 		return typeof stdin === "object" && stdin !== null ? stdin : null;
 	}
 
-	#sendResponse(id: string | number, result?: unknown, error?: JsonRpcError): void {
-		const stdin = this.#getStdin();
-		if (!this.#connected || !stdin) return;
+	async #sendResponse(
+		id: string | number,
+		epoch: number,
+		stdin: Bun.FileSink,
+		result?: unknown,
+		error?: JsonRpcError,
+	): Promise<void> {
 		const response = error
 			? { jsonrpc: "2.0" as const, id, error }
 			: { jsonrpc: "2.0" as const, id, result: result ?? {} };
-		stdin.write(`${JSON.stringify(response)}\n`);
-		stdin.flush();
+		await this.#queueWriteFrame(stdin, `${JSON.stringify(response)}\n`, epoch);
+	}
+
+	#queueWriteFrame(stdin: Bun.FileSink, message: string, epoch: number): Promise<void> {
+		const write = this.#writeQueue
+			.catch(() => {})
+			.then(() => {
+				if (!this.#connected || this.#connectionEpoch !== epoch || this.#getStdin() !== stdin) {
+					throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
+				}
+				return writeStdioFrame(stdin, message);
+			});
+		this.#writeQueue = write.catch(() => {});
+		return write;
+	}
+
+	async #sendResponseOrClose(
+		id: string | number,
+		epoch: number,
+		stdin: Bun.FileSink,
+		result?: unknown,
+		error?: JsonRpcError,
+	): Promise<void> {
+		try {
+			await this.#sendResponse(id, epoch, stdin, result, error);
+		} catch (writeError) {
+			this.#terminalizeFailure(writeError, epoch);
+		}
 	}
 
 	#handleClose(failure?: MCPExpectedFailure): void {
 		void this.#closeInternal(true, failure);
 	}
 
+	#terminalizeFailure(error: unknown, epoch: number): MCPExpectedFailure {
+		const existing = this.#terminalFailure;
+		if (existing?.epoch === epoch) return existing.error;
+		const failure = error instanceof MCPExpectedFailure ? error : new MCPExpectedFailure(error);
+		if (epoch !== this.#connectionEpoch) return failure;
+		this.#terminalFailure = { epoch, error: failure };
+		this.onError?.(failure);
+		this.#handleClose(failure);
+		return failure;
+	}
+
 	async request<T = unknown>(
 		method: string,
 		params?: Record<string, unknown>,
 		options?: MCPRequestOptions,
 	): Promise<T> {
 		const stdin = this.#getStdin();
+		const epoch = this.#connectionEpoch;
 		if (!this.#connected || !stdin) {
-			throw new MCPExpectedFailure();
+			throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
 		}
 
 		const id = Snowflake.next();
@@ -318,12 +378,10 @@ export class StdioTransport implements MCPTransport {
 
 		const message = `${JSON.stringify(request)}\n`;
 		try {
-			// Bun's FileSink has write() method directly
-			stdin.write(message);
-			stdin.flush();
+			await this.#queueWriteFrame(stdin, message, epoch);
 		} catch (error: unknown) {
 			cleanup();
-			reject(new MCPExpectedFailure(error));
+			reject(this.#terminalizeFailure(error, epoch));
 		}
 
 		return promise;
@@ -331,8 +389,9 @@ export class StdioTransport implements MCPTransport {
 
 	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
 		const stdin = this.#getStdin();
+		const epoch = this.#connectionEpoch;
 		if (!this.#connected || !stdin) {
-			throw new MCPExpectedFailure();
+			throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
 		}
 
 		const notification = {
@@ -343,16 +402,20 @@ export class StdioTransport implements MCPTransport {
 
 		const message = `${JSON.stringify(notification)}\n`;
 		try {
-			// Bun's FileSink has write() method directly
-			stdin.write(message);
-			stdin.flush();
+			await this.#queueWriteFrame(stdin, message, epoch);
 		} catch (error) {
-			throw new MCPExpectedFailure(error);
+			throw this.#terminalizeFailure(error, epoch);
 		}
 	}
 
 	async close(): Promise<void> {
-		await this.#closeInternal(false);
+		const epoch = this.#connectionEpoch;
+		let failure = this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : undefined;
+		if (!failure) {
+			failure = new MCPExpectedFailure();
+			this.#terminalFailure = { epoch, error: failure };
+		}
+		await this.#closeInternal(false, failure);
 	}
 
 	#closeInternal(fromReadLoop: boolean, failure?: MCPExpectedFailure): Promise<void> {

package/src/sdk/broker/lifecycle.ts

@@ -25,7 +25,8 @@ import {
 } from "../../session/session-storage";
 import {
 	ensureLaunchWorktree,
-	ensureReusableNodeModules,
+	ensureLaunchWorktreeDependencies,
+	launchWorktreeCwd,
 	planLaunchWorktree,
 	type SkcLaunchWorktreePlan,
 } from "../../skc-runtime/launch-worktree";
@@ -656,7 +657,7 @@ async function validateLiveResumeScope(
 					: { enabled: true, detached: true, name: null },
 			);
 			if (!planned.enabled) return fail("invalid_input", "Lifecycle worktree target is invalid.");
-			cwd = path.resolve(planned.worktreePath);
+			cwd = launchWorktreeCwd(planned);
 		} catch (error) {
 			return fail(
 				"invalid_input",
@@ -2338,7 +2339,7 @@ function preparePlannedWorktree(plan: SkcLaunchWorktreePlan): SessionLifecycleWo
 		throw new Error("Lifecycle worktree preparation did not preserve the durable worktree identity.");
 	return {
 		enabled: true,
-		cwd: path.resolve(prepared.worktreePath),
+		cwd: launchWorktreeCwd(prepared),
 		created: prepared.created,
 		reused: prepared.reused,
 		...(prepared.branchName ? { branch: prepared.branchName } : {}),
@@ -2377,7 +2378,7 @@ async function launchInput(
 			);
 			if (!planned.enabled) return fail("invalid_input", "Lifecycle worktree target is invalid.");
 			worktreePlan = planned;
-			cwd = path.resolve(planned.worktreePath);
+			cwd = launchWorktreeCwd(planned);
 		} catch (error) {
 			return fail(
 				"invalid_input",
@@ -2867,7 +2868,7 @@ async function executeLifecycleResponse(
 					digest: createHash("sha256").update(canonicalJson({ worktree })).digest("hex"),
 				};
 				await broker.ledger.transition(identity, "effect_started", { durableEffects });
-				ensureReusableNodeModules(launch.worktreePlan.repoRoot, launch.worktreePlan.worktreePath);
+				ensureLaunchWorktreeDependencies(launch.worktreePlan);
 			}
 		} catch (error) {
 			return fail(

package/src/sdk/bus/lifecycle-control-runtime.ts

@@ -40,21 +40,27 @@ import {
 	resolveSkcTmuxCommand,
 } from "../../skc-runtime/tmux-common";
 import {
+	abandonIdentityCreate,
+	advanceIdentityCreatePhase,
 	captureOwnerGenerationBaseline,
 	classifyCgroup,
 	isExactScopedBootstrapSuccessReceipt,
 	type OwnerGenerationBaseline,
 	type OwnerIsolationProbe,
 	planTmuxOwnerIsolation,
+	releaseIdentityCreate,
 	replaceOwnerGeneration,
+	reserveIdentityCreate,
 	resolveManagedOwnerPredecessorSync,
 	type TmuxServerProof,
 } from "../../skc-runtime/tmux-owner-isolation";
 import {
+	abandonedIdentityCensus,
 	findSkcTmuxSessionByName,
 	forceCloseSkcTmuxSession,
 	listSkcTmuxSessions,
 	type SkcTmuxSessionStatus,
+	settleAbandonedIdentity,
 } from "../../skc-runtime/tmux-sessions";
 import type {
 	LifecycleErrorReason,
@@ -873,66 +879,103 @@ export function daemonSpawnCreate(
 		const { cwd, args } = buildCreateArgv(frame, ids);
 		const sessionStateFile = lifecycleRuntimeStateFile(cwd, ids.intendedSessionId, name);
 		const stateDir = path.dirname(sessionStateFile);
-		const previousBaseline = await captureOwnerGenerationBaseline(stateDir, ids.intendedSessionId);
-		const predecessor = resolveManagedOwnerPredecessorSync(stateDir, ids.intendedSessionId, previousBaseline);
-		const generation = crypto.randomUUID();
-		const runId = crypto.randomUUID();
-		const incarnation = crypto.randomUUID();
-		// Detached: no interactive TTY needed (daemon-safe). These values contain
-		// only opaque ids and paths needed by the resident sidecar to publish its
-		// exact-owner terminal verdict.
-		const childEnv: Record<string, string> = {
-			SKC_TMUX_LAUNCHED: "1",
-			SKC_NOTIFICATIONS: "1",
-			SKC_SESSION_ID: ids.intendedSessionId,
-			SKC_LIFECYCLE_REQUEST_ID: ids.lifecycleRequestId,
-			[SKC_COORDINATOR_SESSION_ID_ENV]: ids.intendedSessionId,
-			[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
-			[SKC_TMUX_OWNER_GENERATION_ENV]: generation,
-			[SKC_TMUX_OWNER_STATE_DIR_ENV]: stateDir,
-			[SKC_TMUX_OWNER_SERVER_KEY_ENV]: "default",
-			SKC_MANAGED_OWNER_COMMAND_JSON: JSON.stringify(["skc", ...args]),
-			[MANAGED_OWNER_RUN_ID_ENV]: runId,
-			[MANAGED_OWNER_INCARNATION_ENV]: incarnation,
-			...(predecessor
-				? {
-						[MANAGED_OWNER_PREDECESSOR_TOKEN_ENV]: predecessor.predecessorToken,
-						[MANAGED_OWNER_PREDECESSOR_GENERATION_ENV]: predecessor.generation,
-						[MANAGED_OWNER_PREDECESSOR_RUN_ID_ENV]: predecessor.runId,
-						[MANAGED_OWNER_PREDECESSOR_INCARNATION_ENV]: predecessor.incarnation,
-						[MANAGED_OWNER_TRANSCRIPT_PATH_ENV]: env.SKC_SESSION_FILE ?? "",
-					}
-				: {}),
-		};
-		if (ids.startupPromptRef) childEnv.SKC_STARTUP_PROMPT_REF = ids.startupPromptRef;
-		const envPairs = Object.entries(childEnv)
-			.map(([key, value]) => `${key}=${shellQuote(value)}`)
-			.join(" ");
-		const command = `cd ${shellQuote(cwd)} && exec env ${envPairs} skc ${shellQuote(MANAGED_OWNER_SUPERVISOR_ARG)}`;
-		await completeLifecycleSpawnTransaction({
-			tmux,
-			env,
-			sessionId: ids.intendedSessionId,
-			generation,
-			stateDir,
-			cwd,
-			sessionName: name,
-			sessionStateFile,
-			argv: [tmux, "new-session", "-d", "-P", "-F", "#{session_id}", "-s", name, "sh", "-c", command],
-			ownerIsolationProbe: opts.ownerIsolationProbe,
-			prepareSpawn: () => {
-				if (frame.target.kind === "plain_dir") fs.mkdirSync(cwd, { recursive: true });
-			},
-			previousBaseline,
-		});
+		// Shared identity create fence, before the final baseline capture and any
+		// spawn preparation. The SDK-bus producer is a separate implementation
+		// from the notification one and must acquire it in its own right.
+		const identityKey = { stateDir, sessionId: ids.intendedSessionId, stateFile: sessionStateFile };
+		const reserved = reserveIdentityCreate(identityKey);
+		// A dead previous owner that reached the helper may have left an untagged
+		// child. Resolve it authority-first instead of treating the row as a
+		// permanent collision, which would brick this identity forever.
+		const settled = settleAbandonedIdentity(
+			reserved,
+			identityKey,
+			abandonedIdentityCensus(tmux, env, sessionStateFile),
+		);
+		// Fail closed: an unreachable fence cannot honor the one-create guarantee.
+		if (!settled.ok) throw new Error(`skc_lifecycle_identity_create_${settled.code}:${settled.diagnostic}`);
+		let reservation = settled.reservation;
+		let cleanupUncertain = false;
+		try {
+			const previousBaseline = await captureOwnerGenerationBaseline(stateDir, ids.intendedSessionId);
+			const predecessor = resolveManagedOwnerPredecessorSync(stateDir, ids.intendedSessionId, previousBaseline);
+			const generation = crypto.randomUUID();
+			const runId = crypto.randomUUID();
+			const incarnation = crypto.randomUUID();
+			// Detached: no interactive TTY needed (daemon-safe). These values contain
+			// only opaque ids and paths needed by the resident sidecar to publish its
+			// exact-owner terminal verdict.
+			const childEnv: Record<string, string> = {
+				SKC_TMUX_LAUNCHED: "1",
+				SKC_NOTIFICATIONS: "1",
+				SKC_SESSION_ID: ids.intendedSessionId,
+				SKC_LIFECYCLE_REQUEST_ID: ids.lifecycleRequestId,
+				[SKC_COORDINATOR_SESSION_ID_ENV]: ids.intendedSessionId,
+				[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
+				[SKC_TMUX_OWNER_GENERATION_ENV]: generation,
+				[SKC_TMUX_OWNER_STATE_DIR_ENV]: stateDir,
+				[SKC_TMUX_OWNER_SERVER_KEY_ENV]: "default",
+				SKC_MANAGED_OWNER_COMMAND_JSON: JSON.stringify(["skc", ...args]),
+				[MANAGED_OWNER_RUN_ID_ENV]: runId,
+				[MANAGED_OWNER_INCARNATION_ENV]: incarnation,
+				...(predecessor
+					? {
+							[MANAGED_OWNER_PREDECESSOR_TOKEN_ENV]: predecessor.predecessorToken,
+							[MANAGED_OWNER_PREDECESSOR_GENERATION_ENV]: predecessor.generation,
+							[MANAGED_OWNER_PREDECESSOR_RUN_ID_ENV]: predecessor.runId,
+							[MANAGED_OWNER_PREDECESSOR_INCARNATION_ENV]: predecessor.incarnation,
+							[MANAGED_OWNER_TRANSCRIPT_PATH_ENV]: env.SKC_SESSION_FILE ?? "",
+						}
+					: {}),
+			};
+			if (ids.startupPromptRef) childEnv.SKC_STARTUP_PROMPT_REF = ids.startupPromptRef;
+			const envPairs = Object.entries(childEnv)
+				.map(([key, value]) => `${key}=${shellQuote(value)}`)
+				.join(" ");
+			const command = `cd ${shellQuote(cwd)} && exec env ${envPairs} skc ${shellQuote(MANAGED_OWNER_SUPERVISOR_ARG)}`;
+			// Record the attempt name BEFORE anything can spawn. Without this the
+			// reservation stays at `reserved`, and a successor would read a crash
+			// here as "no child can exist" and reclaim an identity that already
+			// has an untagged child.
+			reservation =
+				advanceIdentityCreatePhase(reservation, "helper_invoked", { attemptSessionName: name }) ??
+				(() => {
+					throw new Error("skc_lifecycle_identity_create_fence_lost");
+				})();
+			await completeLifecycleSpawnTransaction({
+				tmux,
+				env,
+				sessionId: ids.intendedSessionId,
+				generation,
+				stateDir,
+				cwd,
+				sessionName: name,
+				sessionStateFile,
+				argv: [tmux, "new-session", "-d", "-P", "-F", "#{session_id}", "-s", name, "sh", "-c", command],
+				ownerIsolationProbe: opts.ownerIsolationProbe,
+				prepareSpawn: () => {
+					if (frame.target.kind === "plain_dir") fs.mkdirSync(cwd, { recursive: true });
+				},
+				previousBaseline,
+			});
 
-		return {
-			sessionId: ids.intendedSessionId,
-			tmuxSession: name,
-			sessionStateFile,
-			endpointUrl: "",
-			topicThreadId: "",
-		};
+			return {
+				sessionId: ids.intendedSessionId,
+				tmuxSession: name,
+				sessionStateFile,
+				endpointUrl: "",
+				topicThreadId: "",
+			};
+		} catch (error) {
+			// `skc_lifecycle_cleanup_uncertain` means a child may survive that we
+			// could not remove. Keep the reservation so its evidence outlives us.
+			if (error instanceof AggregateError && /cleanup_uncertain/.test(String(error.message)))
+				cleanupUncertain = true;
+			throw error;
+		} finally {
+			if (cleanupUncertain) abandonIdentityCreate(reservation);
+			else releaseIdentityCreate(reservation);
+		}
 	};
 }
 
@@ -1086,58 +1129,94 @@ export function daemonResumeSession(
 		const name = tmuxSessionNameFor(resumeId);
 		const sessionStateFile = lifecycleRuntimeStateFile(resolvedResumeCwd, resumeId, name);
 		const stateDir = path.dirname(sessionStateFile);
-		const previousBaseline = await captureOwnerGenerationBaseline(stateDir, resumeId);
-		const predecessor = resolveManagedOwnerPredecessorSync(stateDir, resumeId, previousBaseline);
-		const generation = crypto.randomUUID();
-		const runId = crypto.randomUUID();
-		const incarnation = crypto.randomUUID();
-		const childEnv: Record<string, string> = {
-			SKC_TMUX_LAUNCHED: "1",
-			SKC_NOTIFICATIONS: "1",
-			[SKC_COORDINATOR_SESSION_ID_ENV]: resumeId,
-			[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
-			[SKC_TMUX_OWNER_GENERATION_ENV]: generation,
-			[SKC_TMUX_OWNER_STATE_DIR_ENV]: stateDir,
-			[SKC_TMUX_OWNER_SERVER_KEY_ENV]: "default",
-			SKC_MANAGED_OWNER_COMMAND_JSON: JSON.stringify(["skc", "--resume", resumeId]),
-			[MANAGED_OWNER_RUN_ID_ENV]: runId,
-			[MANAGED_OWNER_INCARNATION_ENV]: incarnation,
-			...(predecessor
-				? {
-						[MANAGED_OWNER_PREDECESSOR_TOKEN_ENV]: predecessor.predecessorToken,
-						[MANAGED_OWNER_PREDECESSOR_GENERATION_ENV]: predecessor.generation,
-						[MANAGED_OWNER_PREDECESSOR_RUN_ID_ENV]: predecessor.runId,
-						[MANAGED_OWNER_PREDECESSOR_INCARNATION_ENV]: predecessor.incarnation,
-						[MANAGED_OWNER_TRANSCRIPT_PATH_ENV]: env.SKC_SESSION_FILE ?? "",
-					}
-				: {}),
-		};
-		const envPairs = Object.entries(childEnv)
-			.map(([key, value]) => `${key}=${shellQuote(value)}`)
-			.join(" ");
-		const command = `cd ${shellQuote(resolvedResumeCwd)} && exec env ${envPairs} skc ${shellQuote(MANAGED_OWNER_SUPERVISOR_ARG)}`;
-		await completeLifecycleSpawnTransaction({
-			tmux,
-			env,
-			sessionId: resumeId,
-			generation,
-			stateDir,
-			cwd: resolvedResumeCwd,
-			sessionName: name,
-			sessionStateFile,
-			argv: [tmux, "new-session", "-d", "-P", "-F", "#{session_id}", "-s", name, "sh", "-c", command],
-			ownerIsolationProbe: opts.ownerIsolationProbe,
-			previousBaseline,
-		});
+		// Same shared fence: the cold restart reuses the historical id, so it can
+		// collide with a restore of that exact identity.
+		const identityKey = { stateDir, sessionId: resumeId, stateFile: sessionStateFile };
+		const reserved = reserveIdentityCreate(identityKey);
+		// A dead previous owner that reached the helper may have left an untagged
+		// child. Resolve it authority-first instead of treating the row as a
+		// permanent collision, which would brick this identity forever.
+		const settled = settleAbandonedIdentity(
+			reserved,
+			identityKey,
+			abandonedIdentityCensus(tmux, env, sessionStateFile),
+		);
+		// Fail closed: an unreachable fence cannot honor the one-create guarantee.
+		if (!settled.ok) throw new Error(`skc_lifecycle_identity_create_${settled.code}:${settled.diagnostic}`);
+		let reservation = settled.reservation;
+		let cleanupUncertain = false;
+		try {
+			const previousBaseline = await captureOwnerGenerationBaseline(stateDir, resumeId);
+			const predecessor = resolveManagedOwnerPredecessorSync(stateDir, resumeId, previousBaseline);
+			const generation = crypto.randomUUID();
+			const runId = crypto.randomUUID();
+			const incarnation = crypto.randomUUID();
+			const childEnv: Record<string, string> = {
+				SKC_TMUX_LAUNCHED: "1",
+				SKC_NOTIFICATIONS: "1",
+				[SKC_COORDINATOR_SESSION_ID_ENV]: resumeId,
+				[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
+				[SKC_TMUX_OWNER_GENERATION_ENV]: generation,
+				[SKC_TMUX_OWNER_STATE_DIR_ENV]: stateDir,
+				[SKC_TMUX_OWNER_SERVER_KEY_ENV]: "default",
+				SKC_MANAGED_OWNER_COMMAND_JSON: JSON.stringify(["skc", "--resume", resumeId]),
+				[MANAGED_OWNER_RUN_ID_ENV]: runId,
+				[MANAGED_OWNER_INCARNATION_ENV]: incarnation,
+				...(predecessor
+					? {
+							[MANAGED_OWNER_PREDECESSOR_TOKEN_ENV]: predecessor.predecessorToken,
+							[MANAGED_OWNER_PREDECESSOR_GENERATION_ENV]: predecessor.generation,
+							[MANAGED_OWNER_PREDECESSOR_RUN_ID_ENV]: predecessor.runId,
+							[MANAGED_OWNER_PREDECESSOR_INCARNATION_ENV]: predecessor.incarnation,
+							[MANAGED_OWNER_TRANSCRIPT_PATH_ENV]: env.SKC_SESSION_FILE ?? "",
+						}
+					: {}),
+			};
+			const envPairs = Object.entries(childEnv)
+				.map(([key, value]) => `${key}=${shellQuote(value)}`)
+				.join(" ");
+			const command = `cd ${shellQuote(resolvedResumeCwd)} && exec env ${envPairs} skc ${shellQuote(MANAGED_OWNER_SUPERVISOR_ARG)}`;
+			// Record the attempt name BEFORE anything can spawn. Without this the
+			// reservation stays at `reserved`, and a successor would read a crash
+			// here as "no child can exist" and reclaim an identity that already
+			// has an untagged child.
+			reservation =
+				advanceIdentityCreatePhase(reservation, "helper_invoked", { attemptSessionName: name }) ??
+				(() => {
+					throw new Error("skc_lifecycle_identity_create_fence_lost");
+				})();
+			await completeLifecycleSpawnTransaction({
+				tmux,
+				env,
+				sessionId: resumeId,
+				generation,
+				stateDir,
+				cwd: resolvedResumeCwd,
+				sessionName: name,
+				sessionStateFile,
+				argv: [tmux, "new-session", "-d", "-P", "-F", "#{session_id}", "-s", name, "sh", "-c", command],
+				ownerIsolationProbe: opts.ownerIsolationProbe,
+				previousBaseline,
+			});
 
-		return {
-			sessionId: resumeId,
-			tmuxSession: name,
-			sessionStateFile,
-			endpointUrl: "",
-			topicThreadId: "",
-			mode: "cold_restarted",
-		};
+			return {
+				sessionId: resumeId,
+				tmuxSession: name,
+				sessionStateFile,
+				endpointUrl: "",
+				topicThreadId: "",
+				mode: "cold_restarted",
+			};
+		} catch (error) {
+			// `skc_lifecycle_cleanup_uncertain` means a child may survive that we
+			// could not remove. Keep the reservation so its evidence outlives us.
+			if (error instanceof AggregateError && /cleanup_uncertain/.test(String(error.message)))
+				cleanupUncertain = true;
+			throw error;
+		} finally {
+			if (cleanupUncertain) abandonIdentityCreate(reservation);
+			else releaseIdentityCreate(reservation);
+		}
 	};
 }
 

package/src/sdk/protocol/operation-inventory.generated.json

@@ -1825,6 +1825,17 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "slash_command:import-session",
+		"sourceFile": "packages/coding-agent/src/slash-commands/builtin-registry.ts",
+		"sourceKind": "slash_command",
+		"decision": "exclude",
+		"rationale": "local transcript-file import into a new session; ACP is explicitly disabled and no SDK operation reads caller-selected host paths",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "slash_command:copy",
 		"sourceFile": "packages/coding-agent/src/slash-commands/builtin-registry.ts",
@@ -2870,6 +2881,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:hasExplicitlyDisabledTools",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal automatic-tool-selection predicate, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:setActiveToolsByName",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4317,6 +4339,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:runPrePromptContextCheckForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only context check seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:setRetainedMemorySampler",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",