@sayknow-cli/coding-agent 0.3.12 → 0.3.13

package/src/skc-runtime/tmux-sessions.ts

@@ -1,14 +1,30 @@
+import { Buffer } from "node:buffer";
+import * as crypto from "node:crypto";
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { resolveSkcTmuxBinary } from "./psmux-detect";
+import { tmuxRuntimeSessionPath } from "./session-layout";
+import {
+	SKC_COORDINATOR_SESSION_ID_ENV,
+	SKC_COORDINATOR_SESSION_STATE_FILE_ENV,
+	SKC_TMUX_OWNER_GENERATION_ENV,
+	SKC_TMUX_OWNER_SERVER_KEY_ENV,
+	SKC_TMUX_OWNER_STATE_DIR_ENV,
+} from "./session-state-sidecar";
 import {
 	buildSkcTmuxExactOptionTarget,
 	buildSkcTmuxExactSessionTarget,
 	buildSkcTmuxProfileCommands,
 	buildSkcTmuxSessionName,
+	buildSkcTmuxSessionSlug,
 	buildSkcTmuxUntaggedSessionError,
 	normalizeTmuxCreatedAt,
 	resolveSkcTmuxCommand,
 	SKC_TMUX_BRANCH_OPTION,
 	SKC_TMUX_BRANCH_SLUG_OPTION,
+	SKC_TMUX_OWNER_GENERATION_OPTION,
+	SKC_TMUX_OWNER_SERVER_KEY_OPTION,
 	SKC_TMUX_PROFILE_OPTION,
 	SKC_TMUX_PROFILE_VALUE,
 	SKC_TMUX_PROJECT_OPTION,
@@ -16,6 +32,23 @@ import {
 	SKC_TMUX_SESSION_STATE_FILE_OPTION,
 	SKC_TMUX_VERSION_OPTION,
 } from "./tmux-common";
+import {
+	captureOwnerGenerationBaselineSync,
+	classifyCgroup,
+	closeExactTmuxOwner,
+	executeTmuxOwnerIsolationPlanSync,
+	isOwnerGenerationBaselineCurrentSync,
+	isValidOwnerVerdict,
+	lifecyclePaths,
+	type OwnerIsolationProbeSync,
+	type OwnerVerdict,
+	type PlanResponse,
+	planTmuxOwnerIsolationSync,
+	replaceOwnerGenerationSync,
+	type TmuxOwnerIsolationExecutionDependencies,
+	type TmuxOwnerIsolationExecutionResult,
+	type TmuxServerProof,
+} from "./tmux-owner-isolation";
 
 export interface SkcTmuxSessionStatus {
 	name: string;
@@ -30,6 +63,9 @@ export interface SkcTmuxSessionStatus {
 	sessionId?: string;
 	sessionStateFile?: string;
 	version?: string;
+	ownerGeneration?: string;
+	nativeSessionId?: string;
+
 	panePids: number[];
 	profile?: string;
 }
@@ -42,6 +78,9 @@ export interface SkcTmuxSessionTagsForGc {
 	sessionId?: string;
 	sessionStateFile?: string;
 	version?: string;
+	ownerGeneration?: string;
+	nativeSessionId?: string;
+
 	createdAt?: string;
 	attached?: boolean;
 	panePids?: number[];
@@ -52,19 +91,88 @@ export interface SkcTmuxSessionsForGc {
 	untagged: SkcTmuxSessionStatus[];
 }
 
+export interface ProvenTmuxSessionIdentity {
+	nativeSessionId: string;
+	serverPid: number;
+	serverStartTime: string;
+}
+
+export interface ExpectedSkcTmuxSessionIdentity {
+	nativeSessionId: string;
+	ownerGeneration: string;
+	sessionId: string;
+	sessionStateFile: string;
+	project: string;
+	createdAt: string;
+}
+
+export interface ExactOwnerIdentity {
+	sessionId: string;
+	stateDir: string;
+	socketKey: string;
+	generation: string;
+	pid: number;
+	startTime: string;
+}
+
+export interface ForceCloseOwnerDependencies {
+	resolveOwner(sessionName: string, env: NodeJS.ProcessEnv): Promise<ExactOwnerIdentity>;
+	signalTerm(pid: number): void;
+	readProcessStartTime(pid: number): Promise<string | null>;
+	cleanupSession(sessionTarget: string, env: NodeJS.ProcessEnv): void;
+	now(): Date;
+	sleep(ms: number): Promise<void>;
+	listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
+}
+
+const FORCE_CLOSE_VERDICT_TIMEOUT_MS = 5_000;
+const FORCE_CLOSE_VERDICT_POLL_MS = 50;
+
+export type CreateOwnerIsolationTestDependencies = {
+	probe?: Partial<OwnerIsolationProbeSync>;
+	execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
+};
+
+let createOwnerIsolationTestDependencies: CreateOwnerIsolationTestDependencies | null = null;
+let mutationServerProofTestDependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null = null;
+
+/** @internal Test-only seam; production create always uses live fail-closed probes. */
+export function __setCreateOwnerIsolationForTests(dependencies: CreateOwnerIsolationTestDependencies | null): void {
+	createOwnerIsolationTestDependencies = dependencies;
+}
+
+/** @internal Test-only seam; production mutations always use live fail-closed proofs. */
+export function __setMutationServerProofForTests(
+	dependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null,
+): void {
+	mutationServerProofTestDependency = dependency;
+}
+
 function runTmux(args: string[], env: NodeJS.ProcessEnv = process.env): string {
 	const tmuxCommand = resolveSkcTmuxCommand(env);
-	const result = Bun.spawnSync([tmuxCommand, ...args], { stdout: "pipe", stderr: "pipe", env });
+	const result = Bun.spawnSync([tmuxCommand, ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env,
+	});
 	if (result.exitCode === 0) return result.stdout.toString();
 	throw new Error(result.stderr.toString().trim() || `tmux ${args.join(" ")} failed`);
 }
+function normalizeExactTmuxTarget(sessionTarget: string, env: NodeJS.ProcessEnv, kind: "session" | "option"): string {
+	if (sessionTarget.startsWith("$")) return sessionTarget;
+	return kind === "option"
+		? buildSkcTmuxExactOptionTarget(sessionTarget, { env })
+		: buildSkcTmuxExactSessionTarget(sessionTarget, { env });
+}
 
-function tryKillSession(sessionName: string, env: NodeJS.ProcessEnv): void {
-	try {
-		runTmux(["kill-session", "-t", buildSkcTmuxExactSessionTarget(sessionName, { env })], env);
-	} catch {
-		// Best-effort cleanup only; preserve the original create/tag failure.
-	}
+function readExactSessionPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[] {
+	return runTmux(
+		["list-panes", "-s", "-t", normalizeExactTmuxTarget(sessionName, env, "session"), "-F", "#{pane_pid}"],
+		env,
+	)
+		.split("\n")
+		.map(value => Number.parseInt(value.trim(), 10))
+		.filter(pid => Number.isSafeInteger(pid) && pid > 0);
 }
 
 function parseBooleanFlag(value: string | undefined): boolean {
@@ -91,8 +199,11 @@ function parseSessionLine(line: string): SkcTmuxSessionStatus | null {
 		project = "",
 		sessionId = "",
 		sessionStateFile = "",
+		ownerGeneration = "",
 		version = "",
+		nativeSessionId = "",
 	] = line.split("\t");
+
 	if (!name) return null;
 	return {
 		name,
@@ -112,6 +223,8 @@ function parseSessionLine(line: string): SkcTmuxSessionStatus | null {
 		sessionId: sessionId || undefined,
 		sessionStateFile: sessionStateFile || undefined,
 		version: version || undefined,
+		ownerGeneration: ownerGeneration || undefined,
+		nativeSessionId: nativeSessionId || undefined,
 	};
 }
 
@@ -148,7 +261,8 @@ function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env):
 				if (!match) return line;
 				const [, name, windows, created] = match;
 				const createdEpoch = String(Math.floor(new Date(`${created} UTC`).getTime() / 1000) || 0);
-				return [name, windows, "0", createdEpoch, "", "", "0", "", "", "", "", "", "", ""].join("\t");
+
+				return [name, windows, "0", createdEpoch, "", "", "0", "", "", "", "", "", "", "", "", ""].join("\t");
 			});
 		}
 	}
@@ -157,7 +271,8 @@ function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env):
 
 function listSessionLines(env: NodeJS.ProcessEnv = process.env): string[] {
 	return runListSessions(
-		`#{session_name}\t#{session_windows}\t#{session_attached}\t#{session_created}\t#{${SKC_TMUX_PROFILE_OPTION}}\t#{session_key_table}\t#{session_panes}\t#{pane_pid}\t#{${SKC_TMUX_BRANCH_OPTION}}\t#{${SKC_TMUX_BRANCH_SLUG_OPTION}}\t#{${SKC_TMUX_PROJECT_OPTION}}\t#{${SKC_TMUX_SESSION_ID_OPTION}}\t#{${SKC_TMUX_SESSION_STATE_FILE_OPTION}}\t#{${SKC_TMUX_VERSION_OPTION}}`,
+		`#{session_name}\t#{session_windows}\t#{session_attached}\t#{session_created}\t#{${SKC_TMUX_PROFILE_OPTION}}\t#{session_key_table}\t#{session_panes}\t#{pane_pid}\t#{${SKC_TMUX_BRANCH_OPTION}}\t#{${SKC_TMUX_BRANCH_SLUG_OPTION}}\t#{${SKC_TMUX_PROJECT_OPTION}}\t#{${SKC_TMUX_SESSION_ID_OPTION}}\t#{${SKC_TMUX_SESSION_STATE_FILE_OPTION}}\t#{${SKC_TMUX_OWNER_GENERATION_OPTION}}\t#{${SKC_TMUX_VERSION_OPTION}}\t#{session_id}`,
+
 		env,
 	);
 }
@@ -242,40 +357,443 @@ export function statusSkcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv
 export function createSkcTmuxSession(env: NodeJS.ProcessEnv = process.env): SkcTmuxSessionStatus {
 	const tmuxCommand = resolveSkcTmuxCommand(env);
 	const sessionName = buildSkcTmuxSessionName(env);
-	// Build a shell-bootstrap command appropriate for the host shell. Psmux on
-	// Windows runs the new-session command through PowerShell, so we use the
-	// $env:VAR = ... assignment form there. POSIX keeps the historical exec
-	// env form so the launched skc inherits SKC_TMUX_LAUNCHED without leaking
-	// into the parent tmux server.
-	const platform = process.platform;
-	const command = platform === "win32" ? "$env:SKC_TMUX_LAUNCHED = '1'; skc" : "exec env SKC_TMUX_LAUNCHED=1 skc";
-	const created = Bun.spawnSync([tmuxCommand, "new-session", "-d", "-s", sessionName, command], {
+	const cwd = process.cwd();
+	const sessionId = env[SKC_COORDINATOR_SESSION_ID_ENV]?.trim() || sessionName;
+	const stateFile =
+		env[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim() ||
+		tmuxRuntimeSessionPath(cwd, env.SKC_SESSION_ID?.trim() || sessionId, buildSkcTmuxSessionSlug(sessionName));
+	const stateDir = path.dirname(stateFile);
+	const generation = crypto.randomUUID();
+	const childEnvironment: Record<string, string> = {
+		SKC_TMUX_LAUNCHED: "1",
+		[SKC_TMUX_OWNER_GENERATION_ENV]: generation,
+		[SKC_TMUX_OWNER_STATE_DIR_ENV]: stateDir,
+		[SKC_TMUX_OWNER_SERVER_KEY_ENV]: tmuxCommand,
+		[SKC_COORDINATOR_SESSION_ID_ENV]: sessionId,
+		[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: stateFile,
+	};
+	const shellQuote = (value: string): string => `'${value.replace(/'/g, `'\\''`)}'`;
+	const powershellQuote = (value: string): string => `'${value.replace(/'/g, "''")}'`;
+	const command =
+		process.platform === "win32"
+			? `${Object.entries(childEnvironment)
+					.map(([name, value]) => `$env:${name} = ${powershellQuote(value)}`)
+					.join("; ")}; skc`
+			: `exec env ${Object.entries(childEnvironment)
+					.map(([name, value]) => `${name}=${shellQuote(value)}`)
+					.join(" ")} skc`;
+	const tmuxArgv = [
+		tmuxCommand,
+		"new-session",
+		"-d",
+		"-s",
+		sessionName,
+		...(process.platform === "win32" ? [] : ["-P", "-F", "#{session_id}"]),
+		command,
+	];
+	function probeTmuxServer(tmuxCommand: string, env: NodeJS.ProcessEnv): TmuxServerProof {
+		if (process.platform !== "linux") {
+			return {
+				state: "safe",
+				pid: 1,
+				startTime: "not-applicable",
+				cgroup: { classification: "not_applicable" },
+			};
+		}
+		const result = Bun.spawnSync([tmuxCommand, "display-message", "-p", "#{pid}"], {
+			stdout: "pipe",
+			stderr: "pipe",
+			env,
+		});
+		if (result.exitCode !== 0) {
+			const diagnostic = result.stderr.toString();
+			return /no server running|failed to connect|error connecting/.test(diagnostic)
+				? { state: "absent" }
+				: { state: "unverifiable" };
+		}
+		const pid = Number(result.stdout.toString().trim());
+		if (!Number.isSafeInteger(pid) || pid <= 0) return { state: "unverifiable" };
+		try {
+			const stat = fsSync.readFileSync(`/proc/${pid}/stat`, "utf8");
+			const startTime = stat
+				.slice(stat.lastIndexOf(")") + 2)
+				.trim()
+				.split(/\s+/)[19];
+			if (!startTime) return { state: "unverifiable" };
+			const cgroup = classifyCgroup({
+				platform: process.platform,
+				cgroupText: fsSync.readFileSync(`/proc/${pid}/cgroup`, "utf8"),
+			});
+			return {
+				state:
+					cgroup.classification === "safe"
+						? "safe"
+						: cgroup.classification === "unsafe_service"
+							? "unsafe"
+							: "unverifiable",
+				pid,
+				startTime,
+				cgroup,
+			};
+		} catch {
+			return { state: "unverifiable" };
+		}
+	}
+
+	const probeServer = () => probeTmuxServer(tmuxCommand, env);
+
+	const testOwnerProbe = createOwnerIsolationTestDependencies?.probe;
+	const ownerProbe: OwnerIsolationProbeSync = {
+		readCallerCgroup:
+			testOwnerProbe?.readCallerCgroup ??
+			(() => {
+				try {
+					return fsSync.readFileSync("/proc/self/cgroup", "utf8");
+				} catch {
+					return null;
+				}
+			}),
+		probeServer: testOwnerProbe?.probeServer ?? probeServer,
+		recordAttempt:
+			testOwnerProbe?.recordAttempt ??
+			(({ attempt }) => {
+				const root = lifecyclePaths(stateDir, sessionId, generation).root;
+				const attemptFile = path.join(root, `attempt-${attempt.token}.json`);
+				fsSync.mkdirSync(root, { recursive: true, mode: 0o700 });
+				const descriptor = fsSync.openSync(attemptFile, "wx", 0o600);
+				try {
+					fsSync.writeFileSync(
+						descriptor,
+						`${JSON.stringify({
+							schema_version: 1,
+							generation,
+							session_id: sessionId,
+							...attempt,
+							created_at: new Date().toISOString(),
+						})}\n`,
+					);
+					fsSync.fsyncSync(descriptor);
+				} finally {
+					fsSync.closeSync(descriptor);
+				}
+				const directory = fsSync.openSync(root, "r");
+				try {
+					fsSync.fsyncSync(directory);
+				} finally {
+					fsSync.closeSync(directory);
+				}
+			}),
+	};
+	if (resolveSkcTmuxBinary({ env }).isPsmux)
+		throw new Error("skc_tmux_owner_isolation_native_session_identity_unavailable");
+
+	const baseline = captureOwnerGenerationBaselineSync(stateDir, sessionId);
+	const ownerPlan = planTmuxOwnerIsolationSync(
+		{
+			schema_version: 1,
+			op: "plan",
+			platform: process.platform,
+			session_id: sessionId,
+			owner_generation: generation,
+			baseline,
+			cwd,
+			state_dir: stateDir,
+			socket_key: tmuxCommand,
+			tmux_argv: tmuxArgv,
+		},
+		ownerProbe,
+	);
+	if (!ownerPlan.ok) throw new Error(`skc_tmux_owner_isolation_${ownerPlan.code}:${ownerPlan.diagnostic}`);
+
+	const outcome = (createOwnerIsolationTestDependencies?.execute ?? executeTmuxOwnerIsolationPlanSync)(ownerPlan, {
+		socketKey: tmuxCommand,
+		spawn: (argv, stdinLine) => {
+			const result = stdinLine
+				? Bun.spawnSync(argv, {
+						stdout: "pipe",
+						stderr: "pipe",
+						stdin: Buffer.from(stdinLine),
+						env,
+					})
+				: Bun.spawnSync(argv, { stdout: "pipe", stderr: "pipe", env });
+			return { exitCode: result.exitCode, stdout: result.stdout.toString() };
+		},
+		probeServer: ownerProbe.probeServer,
+		isCurrentGeneration: () => isOwnerGenerationBaselineCurrentSync(stateDir, sessionId, baseline),
+		cleanupSpawned: ({ execution, nativeSessionId, server }) => {
+			if (!server.pid || !server.startTime) throw new Error("skc_tmux_cleanup_target_changed");
+			cleanupExactCreatedTmuxSession(
+				nativeSessionId,
+				execution.attempt_session,
+				tmuxCommand,
+				env,
+				server.pid,
+				server.startTime,
+			);
+		},
+	});
+	if (!outcome.ok) throw new Error(`skc_tmux_owner_isolation_${outcome.code}:${outcome.diagnostic}`);
+
+	const nativeSessionId = outcome.native_session_id;
+	if (!nativeSessionId) throw new Error("skc_tmux_owner_isolation_native_session_identity_unavailable");
+	const server = requireSafeTmuxServerForMutation(tmuxCommand, env);
+	if (server.pid !== outcome.server_pid || server.startTime !== outcome.server_start_time)
+		throw new Error("skc_tmux_owner_changed_after_create");
+	if (!isNativeTmuxSessionBoundToName(nativeSessionId, sessionName, env))
+		throw new Error("skc_tmux_owner_changed_after_create");
+
+	try {
+		tagCreatedTmuxSession(
+			nativeSessionId,
+			sessionName,
+			outcome.server_pid,
+			env,
+			{
+				sessionId,
+				sessionStateFile: stateFile,
+				ownerGeneration: generation,
+				ownerServerKey: tmuxCommand,
+				version: env.npm_package_version ?? null,
+			},
+			tmuxCommand,
+		);
+	} catch (tagError) {
+		try {
+			cleanupExactCreatedTmuxSession(
+				nativeSessionId,
+				sessionName,
+				tmuxCommand,
+				env,
+				outcome.server_pid,
+				outcome.server_start_time,
+			);
+		} catch (cleanupError) {
+			throw new AggregateError([tagError, cleanupError], "skc_tmux_profile_tag_failed_cleanup_failed");
+		}
+		throw tagError;
+	}
+
+	if (nativeSessionId) {
+		const firstServer = requireSafeTmuxServerForMutation(tmuxCommand, env);
+		if (firstServer.pid !== outcome.server_pid || firstServer.startTime !== outcome.server_start_time)
+			throw new Error("skc_tmux_owner_changed_after_create");
+		const status = statusSkcTmuxSessionByNativeId(nativeSessionId, env);
+		const finalServer = requireSafeTmuxServerForMutation(tmuxCommand, env);
+		if (finalServer.pid !== firstServer.pid || finalServer.startTime !== firstServer.startTime)
+			throw new Error("skc_tmux_owner_changed_after_create");
+		try {
+			replaceOwnerGenerationSync(stateDir, sessionId, generation, baseline);
+		} catch (publicationError) {
+			try {
+				cleanupExactCreatedTmuxSession(
+					nativeSessionId,
+					sessionName,
+					tmuxCommand,
+					env,
+					outcome.server_pid,
+					outcome.server_start_time,
+				);
+			} catch (cleanupError) {
+				throw new AggregateError(
+					[publicationError, cleanupError],
+					"skc_tmux_owner_generation_publish_failed_cleanup_failed",
+				);
+			}
+			throw publicationError;
+		}
+		return status;
+	}
+	try {
+		replaceOwnerGenerationSync(stateDir, sessionId, generation, baseline);
+	} catch (publicationError) {
+		try {
+			cleanupExactCreatedTmuxSession(
+				nativeSessionId,
+				sessionName,
+				tmuxCommand,
+				env,
+				outcome.server_pid,
+				outcome.server_start_time,
+			);
+		} catch (cleanupError) {
+			throw new AggregateError(
+				[publicationError, cleanupError],
+				"skc_tmux_owner_generation_publish_failed_cleanup_failed",
+			);
+		}
+		throw publicationError;
+	}
+	return statusSkcTmuxSession(sessionName, env);
+}
+
+function statusSkcTmuxSessionByNativeId(nativeSessionId: string, env: NodeJS.ProcessEnv): SkcTmuxSessionStatus {
+	const name = runTmux(
+		["display-message", "-p", "-t", normalizeExactTmuxTarget(nativeSessionId, env, "option"), "#{session_name}"],
+		env,
+	).trim();
+	if (!name || readNativeTmuxSessionId(nativeSessionId, env) !== nativeSessionId)
+		throw new Error(`skc_tmux_owner_changed:${nativeSessionId}`);
+	return statusSkcTmuxSession(name, env);
+}
+
+function tmuxCommandArgument(value: string): string {
+	return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("$", "\\$").replaceAll("`", "\\`")}"`;
+}
+
+function guardedTmuxSessionPredicate(
+	expectedPid: number,
+	nativeSessionId: string,
+	sessionName: string,
+	expectedOwnerGeneration?: string,
+): string {
+	const ownerGenerationPredicate = expectedOwnerGeneration
+		? `#{==:#{${SKC_TMUX_OWNER_GENERATION_OPTION}},${expectedOwnerGeneration}}`
+		: "1";
+	return `#{&&:#{==:#{pid},${expectedPid}},#{&&:#{==:#{session_id},${nativeSessionId}},#{&&:#{==:#{session_name},${sessionName}},${ownerGenerationPredicate}}}}`;
+}
+
+function runGuardedTmuxSessionCommand(
+	nativeSessionId: string,
+	sessionName: string,
+	expectedPid: number,
+	env: NodeJS.ProcessEnv,
+	thenCommand: string,
+	expectedOwnerGeneration?: string,
+): void {
+	const result = runTmux(
+		[
+			"if-shell",
+			"-t",
+			normalizeExactTmuxTarget(nativeSessionId, env, "session"),
+			"-F",
+			guardedTmuxSessionPredicate(expectedPid, nativeSessionId, sessionName, expectedOwnerGeneration),
+			`${thenCommand} ; display-message -p __skc_tmux_guarded_mutation_ok__`,
+			"display-message -p __skc_tmux_guarded_mutation_refused__",
+		],
+		env,
+	).trim();
+	if (result !== "__skc_tmux_guarded_mutation_ok__") throw new Error("skc_tmux_cleanup_target_changed");
+}
+
+function tagCreatedTmuxSession(
+	nativeSessionId: string,
+	sessionName: string,
+	expectedPid: number,
+	env: NodeJS.ProcessEnv,
+	metadata: {
+		branch?: string | null;
+		branchSlug?: string | null;
+		project?: string | null;
+		sessionId?: string | null;
+		sessionStateFile?: string | null;
+		ownerGeneration?: string | null;
+		ownerServerKey?: string | null;
+		version?: string | null;
+	},
+	tmuxCommand: string,
+): void {
+	const target = `${nativeSessionId}:`;
+	const commands = buildSkcTmuxProfileCommands(target, env, metadata, { tmuxCommand })
+		.map(command => command.args.map(tmuxCommandArgument).join(" "))
+		.join(" ; ");
+	runGuardedTmuxSessionCommand(nativeSessionId, sessionName, expectedPid, env, commands);
+}
+
+function cleanupExactCreatedTmuxSession(
+	nativeSessionId: string,
+	sessionName: string,
+	tmuxCommand: string,
+	env: NodeJS.ProcessEnv,
+	expectedPid: number,
+	expectedStartTime: string,
+): void {
+	const server = requireSafeTmuxServerForMutation(tmuxCommand, env);
+	if (server.pid !== expectedPid || server.startTime !== expectedStartTime)
+		throw new Error("skc_tmux_cleanup_target_changed");
+	runGuardedTmuxSessionCommand(
+		nativeSessionId,
+		sessionName,
+		expectedPid,
+		env,
+		`kill-session -t ${tmuxCommandArgument(normalizeExactTmuxTarget(nativeSessionId, env, "session"))}`,
+	);
+}
+
+function requireSafeTmuxServerForMutation(
+	tmuxCommand: string,
+	env: NodeJS.ProcessEnv,
+): { pid: number; startTime: string } {
+	if (mutationServerProofTestDependency) {
+		const proof = mutationServerProofTestDependency(tmuxCommand, env);
+		if (
+			proof &&
+			typeof proof === "object" &&
+			Number.isSafeInteger((proof as { pid?: unknown }).pid) &&
+			typeof (proof as { startTime?: unknown }).startTime === "string"
+		)
+			return proof as { pid: number; startTime: string };
+		return { pid: 1, startTime: "test" };
+	}
+	if (process.platform !== "linux") return { pid: 1, startTime: "not-applicable" };
+	const result = Bun.spawnSync([tmuxCommand, "display-message", "-p", "#{pid}"], {
 		stdout: "pipe",
 		stderr: "pipe",
 		env,
 	});
-	if (created.exitCode !== 0) throw new Error(created.stderr.toString().trim() || "skc_tmux_session_create_failed");
+	if (result.exitCode !== 0) throw new Error("skc_tmux_owner_isolation_server_unverifiable");
+	const pid = Number(result.stdout.toString().trim());
+	if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error("skc_tmux_owner_isolation_server_unverifiable");
 	try {
-		// psmux 3.3.0 rejects the tmux `=NAME` exact-session prefix for option
-		// commands, so the target is the bare session name on psmux and the
-		// window-qualified `=NAME:` on tmux. The ownership-tag round-trip
-		// (set-option @skc-*) is preserved on both; only the UX profile commands
-		// (mouse / set-clipboard / mode-style / set-window-option) get filtered
-		// by buildSkcTmuxProfileCommands when the active binary is psmux.
-		const target = buildSkcTmuxExactOptionTarget(sessionName, { env });
-		for (const profileCommand of buildSkcTmuxProfileCommands(target, env, {}, { tmuxCommand })) {
-			runTmux(profileCommand.args, env);
-		}
+		const stat = fsSync.readFileSync(`/proc/${pid}/stat`, "utf8");
+		const startTime = stat
+			.slice(stat.lastIndexOf(")") + 2)
+			.trim()
+			.split(/\s+/)[19];
+		const cgroup = classifyCgroup({
+			platform: process.platform,
+			cgroupText: fsSync.readFileSync(`/proc/${pid}/cgroup`, "utf8"),
+		});
+		if (!startTime || cgroup.classification !== "safe")
+			throw new Error(
+				`skc_tmux_owner_isolation_${cgroup.classification === "unsafe_service" ? "server_unsafe" : "server_unverifiable"}`,
+			);
+		return { pid, startTime };
 	} catch (error) {
-		tryKillSession(sessionName, env);
-		throw error;
+		if (error instanceof Error && error.message.startsWith("skc_tmux_owner_isolation_")) throw error;
+		throw new Error("skc_tmux_owner_isolation_server_unverifiable");
 	}
-	return statusSkcTmuxSession(sessionName, env);
+}
+
+/** Proves a managed reusable name still resolves to one immutable session on one server. */
+export function proveSkcTmuxSessionMutationTarget(
+	sessionName: string,
+	env: NodeJS.ProcessEnv = process.env,
+): ProvenTmuxSessionIdentity {
+	const session = statusSkcTmuxSession(sessionName, env);
+	if (readProfileForExactTarget(session.name, env) !== SKC_TMUX_PROFILE_VALUE)
+		throw new Error(`skc_tmux_session_not_managed:${sessionName}`);
+	const firstServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+	if (resolveSkcTmuxBinary({ env }).isPsmux) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	const nativeSessionId = readNativeTmuxSessionId(session.name, env);
+	if (!nativeSessionId) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	if (
+		readNativeTmuxSessionId(nativeSessionId, env) !== nativeSessionId ||
+		readProfileForExactTarget(nativeSessionId, env) !== SKC_TMUX_PROFILE_VALUE
+	)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	const finalServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+	if (finalServer.pid !== firstServer.pid || finalServer.startTime !== firstServer.startTime)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	return {
+		nativeSessionId,
+		serverPid: finalServer.pid,
+		serverStartTime: finalServer.startTime,
+	};
 }
 
 function readProfileForExactTarget(sessionName: string, env: NodeJS.ProcessEnv): string {
 	const raw = runTmux(
-		["show-options", "-qv", "-t", buildSkcTmuxExactOptionTarget(sessionName, { env }), SKC_TMUX_PROFILE_OPTION],
+		["show-options", "-qv", "-t", normalizeExactTmuxTarget(sessionName, env, "option"), SKC_TMUX_PROFILE_OPTION],
 		env,
 	).trim();
 	// tmux returns just the value; psmux returns `key value`. Strip the
@@ -291,7 +809,7 @@ function readProfileForExactTarget(sessionName: string, env: NodeJS.ProcessEnv):
 function readExactOptionForGc(sessionName: string, option: string, env: NodeJS.ProcessEnv): string | undefined {
 	try {
 		const raw = runTmux(
-			["show-options", "-qv", "-t", buildSkcTmuxExactOptionTarget(sessionName, { env }), option],
+			["show-options", "-qv", "-t", normalizeExactTmuxTarget(sessionName, env, "option"), option],
 			env,
 		).trim();
 		if (!raw) return undefined;
@@ -316,6 +834,38 @@ function readExactOptionForGc(sessionName: string, option: string, env: NodeJS.P
 	}
 }
 
+function readNativeTmuxSessionId(sessionTarget: string, env: NodeJS.ProcessEnv): string | undefined {
+	if (resolveSkcTmuxBinary({ env }).isPsmux) return undefined;
+	try {
+		const sessionId = runTmux(
+			["display-message", "-p", "-t", normalizeExactTmuxTarget(sessionTarget, env, "option"), "#{session_id}"],
+			env,
+		).trim();
+		return sessionId || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isNativeTmuxSessionBoundToName(nativeSessionId: string, sessionName: string, env: NodeJS.ProcessEnv): boolean {
+	try {
+		return (
+			runTmux(
+				[
+					"display-message",
+					"-p",
+					"-t",
+					normalizeExactTmuxTarget(sessionName, env, "option"),
+					"#{session_id}\t#{session_name}",
+				],
+				env,
+			).trim() === `${nativeSessionId}\t${sessionName}`
+		);
+	} catch {
+		return false;
+	}
+}
+
 function hydrateSessionFromExactOptions(session: SkcTmuxSessionStatus, env: NodeJS.ProcessEnv): SkcTmuxSessionStatus {
 	if (session.profile === SKC_TMUX_PROFILE_VALUE) return session;
 	const profile = readExactOptionForGc(session.name, SKC_TMUX_PROFILE_OPTION, env);
@@ -329,6 +879,9 @@ function hydrateSessionFromExactOptions(session: SkcTmuxSessionStatus, env: Node
 		sessionId: session.sessionId ?? readExactOptionForGc(session.name, SKC_TMUX_SESSION_ID_OPTION, env),
 		sessionStateFile:
 			session.sessionStateFile ?? readExactOptionForGc(session.name, SKC_TMUX_SESSION_STATE_FILE_OPTION, env),
+		ownerGeneration:
+			session.ownerGeneration ?? readExactOptionForGc(session.name, SKC_TMUX_OWNER_GENERATION_OPTION, env),
+
 		version: session.version ?? readExactOptionForGc(session.name, SKC_TMUX_VERSION_OPTION, env),
 	};
 }
@@ -347,71 +900,321 @@ export function readTmuxSessionTagsForGc(
 		sessionId: readExactOptionForGc(sessionName, SKC_TMUX_SESSION_ID_OPTION, env),
 		sessionStateFile: readExactOptionForGc(sessionName, SKC_TMUX_SESSION_STATE_FILE_OPTION, env),
 		version: readExactOptionForGc(sessionName, SKC_TMUX_VERSION_OPTION, env),
+		ownerGeneration: readExactOptionForGc(sessionName, SKC_TMUX_OWNER_GENERATION_OPTION, env),
+		nativeSessionId: session?.nativeSessionId,
 		createdAt: session?.createdAt,
 		attached: session?.attached,
 		panePids: session?.panePids,
 	};
 }
 
-export function removeSkcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): SkcTmuxSessionStatus {
+export function removeSkcTmuxSession(
+	sessionName: string,
+	env: NodeJS.ProcessEnv = process.env,
+	expectedIdentity?: ExpectedSkcTmuxSessionIdentity,
+): SkcTmuxSessionStatus {
 	const session = statusSkcTmuxSession(sessionName, env);
 	if (session.attached || session.panePids.length > 0) {
 		throw new Error(`skc_tmux_session_live:${sessionName}`);
 	}
+	if (
+		expectedIdentity &&
+		(session.nativeSessionId !== expectedIdentity.nativeSessionId ||
+			session.ownerGeneration !== expectedIdentity.ownerGeneration ||
+			session.sessionId !== expectedIdentity.sessionId ||
+			session.sessionStateFile !== expectedIdentity.sessionStateFile ||
+			session.project !== expectedIdentity.project ||
+			session.createdAt !== expectedIdentity.createdAt)
+	)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
 	if (readProfileForExactTarget(session.name, env) !== SKC_TMUX_PROFILE_VALUE) {
 		throw new Error(`skc_tmux_session_not_managed:${sessionName}`);
 	}
-	runTmux(["kill-session", "-t", buildSkcTmuxExactSessionTarget(session.name, { env })], env);
+	if (resolveSkcTmuxBinary({ env }).isPsmux) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	const nativeSessionId = readNativeTmuxSessionId(session.name, env);
+	if (!nativeSessionId) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	if (expectedIdentity && nativeSessionId !== expectedIdentity.nativeSessionId)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	if (
+		expectedIdentity &&
+		readExactOptionForGc(session.name, SKC_TMUX_OWNER_GENERATION_OPTION, env) !== expectedIdentity.ownerGeneration
+	)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	const firstServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+	if (
+		readNativeTmuxSessionId(nativeSessionId, env) !== nativeSessionId ||
+		readProfileForExactTarget(nativeSessionId, env) !== SKC_TMUX_PROFILE_VALUE
+	)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	const finalServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+	if (finalServer.pid !== firstServer.pid || finalServer.startTime !== firstServer.startTime)
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	runGuardedTmuxSessionCommand(
+		nativeSessionId,
+		session.name,
+		finalServer.pid,
+		env,
+		`kill-session -t '${nativeSessionId}'`,
+		expectedIdentity?.ownerGeneration,
+	);
 	return session;
 }
 
+async function readProcessStartTime(pid: number): Promise<string | null> {
+	try {
+		const stat = await fs.readFile(`/proc/${pid}/stat`, "utf8");
+		const close = stat.lastIndexOf(")");
+		const fields = stat
+			.slice(close + 2)
+			.trim()
+			.split(/\s+/);
+		return fields[19] ?? null;
+	} catch {
+		return null;
+	}
+}
+
+async function readCurrentGeneration(stateDir: string, sessionId: string): Promise<string | null> {
+	try {
+		const value: unknown = JSON.parse(
+			await fs.readFile(path.join(stateDir, sessionId, "owner-lifecycle", "generation.json"), "utf8"),
+		);
+		return typeof value === "object" &&
+			value !== null &&
+			typeof (value as { generation?: unknown }).generation === "string"
+			? (value as { generation: string }).generation
+			: null;
+	} catch {
+		return null;
+	}
+}
+
+async function resolveExactOwner(
+	sessionName: string,
+	env: NodeJS.ProcessEnv,
+	exactPanePid: number,
+): Promise<ExactOwnerIdentity> {
+	const session = statusSkcTmuxSession(sessionName, env);
+	const sessionId = readExactOptionForGc(session.name, SKC_TMUX_SESSION_ID_OPTION, env);
+	const stateFile = readExactOptionForGc(session.name, SKC_TMUX_SESSION_STATE_FILE_OPTION, env);
+	const ownerGeneration = readExactOptionForGc(session.name, SKC_TMUX_OWNER_GENERATION_OPTION, env);
+	const ownerServerKey = readExactOptionForGc(session.name, SKC_TMUX_OWNER_SERVER_KEY_OPTION, env);
+
+	if (!sessionId || !stateFile) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	const stateDir = path.dirname(stateFile);
+	const generation = await readCurrentGeneration(stateDir, sessionId);
+	const pid = exactPanePid;
+	const startTime = await readProcessStartTime(pid);
+	if (!generation || !ownerGeneration || ownerGeneration !== generation || !ownerServerKey || !startTime)
+		throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+
+	return {
+		sessionId,
+		stateDir,
+		socketKey: ownerServerKey,
+		generation,
+		pid,
+		startTime,
+	};
+}
+
+async function requireUnchangedOwnerForCompatibilityCleanup(
+	sessionName: string,
+	nativeSessionId: string,
+	env: NodeJS.ProcessEnv,
+	identity: ExactOwnerIdentity,
+	initialStateFile: string,
+	initialServer: { pid: number; startTime: string },
+	listPanePids: (sessionName: string, env: NodeJS.ProcessEnv) => number[],
+	readStartTime: (pid: number) => Promise<string | null>,
+): Promise<void> {
+	try {
+		const currentNativeSessionId = readNativeTmuxSessionId(nativeSessionId, env);
+		if (!currentNativeSessionId) {
+			if (readNativeTmuxSessionId(sessionName, env)) throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+			return;
+		}
+		const currentServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+		const panePids = listPanePids(nativeSessionId, env);
+		let currentPaneStartTime: string | null;
+		try {
+			currentPaneStartTime = await readStartTime(identity.pid);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			currentPaneStartTime = null;
+		}
+		const mismatches = [
+			currentServer.pid !== initialServer.pid ? "server_pid" : null,
+			currentServer.startTime !== initialServer.startTime ? "server_start" : null,
+			currentNativeSessionId !== nativeSessionId ? "native_id" : null,
+			readProfileForExactTarget(nativeSessionId, env) !== SKC_TMUX_PROFILE_VALUE ? "profile" : null,
+			panePids.length > 1 ? "pane_count" : null,
+			panePids.length === 1 && panePids[0] !== identity.pid ? "pane_pid" : null,
+			currentPaneStartTime !== null && currentPaneStartTime !== identity.startTime ? "pane_start" : null,
+			readExactOptionForGc(nativeSessionId, SKC_TMUX_SESSION_ID_OPTION, env) !== identity.sessionId
+				? "session_id"
+				: null,
+			readExactOptionForGc(nativeSessionId, SKC_TMUX_SESSION_STATE_FILE_OPTION, env) !== initialStateFile
+				? "state_file"
+				: null,
+			readExactOptionForGc(nativeSessionId, SKC_TMUX_OWNER_GENERATION_OPTION, env) !== identity.generation
+				? "generation"
+				: null,
+			readExactOptionForGc(nativeSessionId, SKC_TMUX_OWNER_SERVER_KEY_OPTION, env) !== identity.socketKey
+				? "server_key"
+				: null,
+		].filter((value): value is string => value !== null);
+		if (mismatches.length > 0) throw new Error(`skc_tmux_owner_changed:${sessionName}:${mismatches.join(",")}`);
+	} catch (error) {
+		if (!readNativeTmuxSessionId(nativeSessionId, env)) {
+			if (readNativeTmuxSessionId(sessionName, env)) throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+			return;
+		}
+		if (error instanceof Error && error.message.startsWith(`skc_tmux_owner_changed:${sessionName}`))
+			throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+		throw new Error(`skc_tmux_owner_changed:${sessionName}`);
+	}
+}
+
+async function waitForExpectedVerdict(
+	identity: ExactOwnerIdentity,
+	sleep: (ms: number) => Promise<void>,
+	now: () => Date,
+): Promise<OwnerVerdict | null> {
+	const deadline = now().getTime() + FORCE_CLOSE_VERDICT_TIMEOUT_MS;
+	const paths = lifecyclePaths(identity.stateDir, identity.sessionId, identity.generation);
+	const verdictFile = paths.verdictFile;
+	const verdictAliasFile = paths.verdictAliasFile;
+	while (now().getTime() <= deadline) {
+		try {
+			const [verdictBody, aliasBody] = await Promise.all([
+				fs.readFile(verdictFile, "utf8"),
+				fs.readFile(verdictAliasFile, "utf8"),
+			]);
+			const verdict: unknown = JSON.parse(verdictBody);
+			const alias: unknown = JSON.parse(aliasBody);
+			if (
+				isValidOwnerVerdict(verdict) &&
+				typeof alias === "object" &&
+				alias !== null &&
+				Object.keys(alias).length === Object.keys(verdict).length + 1 &&
+				Object.keys(alias).every(key => key === "owner_generation" || Object.hasOwn(verdict, key)) &&
+				(alias as Record<string, unknown>).owner_generation === identity.generation &&
+				Object.entries(verdict).every(
+					([key, value]) => Object.hasOwn(alias, key) && (alias as Record<string, unknown>)[key] === value,
+				) &&
+				verdict.generation === identity.generation &&
+				verdict.session_id === identity.sessionId &&
+				verdict.server_key === identity.socketKey &&
+				verdict.signal === "SIGTERM" &&
+				verdict.result === "owner_term_then_session_cleanup" &&
+				verdict.classification === "expected_operator_shutdown"
+			)
+				return verdict;
+		} catch {}
+		await sleep(FORCE_CLOSE_VERDICT_POLL_MS);
+	}
+	return null;
+}
+
 /**
- * Force-close a SKC-managed tmux session, even if a live pane is attached.
- *
- * This is the lifecycle-control counterpart to {@link removeSkcTmuxSession}: it
- * intentionally does NOT refuse live/attached panes (hard-kill is the contract),
- * but it keeps every safety check so it can only ever kill a genuinely
- * SKC-managed session:
- * - re-reads the exact tmux profile immediately before kill (never a non-SKC
- *   session, even one that collides by name);
- * - when `expectedSessionId` is given, requires the `@skc-session-id` tag match;
- * - when `expectedStateFile` is given, requires the `@skc-session-state-file`
- *   tag match.
- *
- * Returns the prior status (for audit). Throws a tagged error otherwise:
- * `skc_tmux_session_not_found`, `skc_tmux_session_not_managed`,
- * `skc_tmux_session_id_mismatch`, or `skc_tmux_session_state_file_mismatch`.
+ * Requests an exact tagged owner shutdown. Session cleanup is compatibility-only
+ * and follows a validated SIGTERM verdict; it never authorizes the close.
  */
-export function forceCloseSkcTmuxSession(
+export async function forceCloseSkcTmuxSession(
 	sessionName: string,
 	env: NodeJS.ProcessEnv = process.env,
 	expectedSessionId?: string,
 	expectedStateFile?: string,
-): SkcTmuxSessionStatus {
+	deps: Partial<ForceCloseOwnerDependencies> = {},
+): Promise<SkcTmuxSessionStatus> {
+	if (resolveSkcTmuxBinary({ env }).isPsmux) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
 	const session = statusSkcTmuxSession(sessionName, env);
-	if (readProfileForExactTarget(session.name, env) !== SKC_TMUX_PROFILE_VALUE) {
+	if (readProfileForExactTarget(session.name, env) !== SKC_TMUX_PROFILE_VALUE)
 		throw new Error(`skc_tmux_session_not_managed:${sessionName}`);
-	}
-	if (expectedSessionId !== undefined) {
-		const actual = readExactOptionForGc(session.name, SKC_TMUX_SESSION_ID_OPTION, env);
-		if (actual !== expectedSessionId) {
-			throw new Error(`skc_tmux_session_id_mismatch:${sessionName}`);
-		}
-	}
-	if (expectedStateFile !== undefined) {
-		const actual = readExactOptionForGc(session.name, SKC_TMUX_SESSION_STATE_FILE_OPTION, env);
-		if (actual !== expectedStateFile) {
-			throw new Error(`skc_tmux_session_state_file_mismatch:${sessionName}`);
-		}
-	}
-	// Intentionally NOT refusing live/attached panes — force-close is hard-kill.
-	runTmux(["kill-session", "-t", buildSkcTmuxExactSessionTarget(session.name, { env })], env);
+	const exactPanePids = (deps.listPanePids ?? readExactSessionPanePids)(session.name, env);
+	if (exactPanePids.length !== 1) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	const actualSessionId = readExactOptionForGc(session.name, SKC_TMUX_SESSION_ID_OPTION, env);
+	const actualStateFile = readExactOptionForGc(session.name, SKC_TMUX_SESSION_STATE_FILE_OPTION, env);
+	const actualGeneration = readExactOptionForGc(session.name, SKC_TMUX_OWNER_GENERATION_OPTION, env);
+	const actualServerKey = readExactOptionForGc(session.name, SKC_TMUX_OWNER_SERVER_KEY_OPTION, env);
+
+	if (expectedSessionId !== undefined && actualSessionId !== expectedSessionId)
+		throw new Error(`skc_tmux_session_id_mismatch:${sessionName}`);
+	if (expectedStateFile !== undefined && actualStateFile !== expectedStateFile)
+		throw new Error(`skc_tmux_session_state_file_mismatch:${sessionName}`);
+	if (!actualSessionId || !actualStateFile || !actualGeneration || !actualServerKey)
+		throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+	const nativeSessionId = readNativeTmuxSessionId(session.name, env);
+	if (!nativeSessionId) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
+
+	const resolveOwner =
+		deps.resolveOwner ?? ((name, targetEnv) => resolveExactOwner(name, targetEnv, exactPanePids[0]!));
+	const identity = await resolveOwner(session.name, env);
+	if (identity.pid !== exactPanePids[0]) throw new Error(`skc_tmux_owner_identity_mismatch:${sessionName}`);
+	if (identity.sessionId !== actualSessionId || identity.stateDir !== path.dirname(actualStateFile))
+		throw new Error(`skc_tmux_owner_identity_mismatch:${sessionName}`);
+	if (identity.generation !== actualGeneration) throw new Error(`skc_tmux_owner_generation_mismatch:${sessionName}`);
+	if (identity.socketKey !== actualServerKey) throw new Error(`skc_tmux_owner_server_key_mismatch:${sessionName}`);
+	const initialServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
+
+	const currentStartTime = await (deps.readProcessStartTime ?? readProcessStartTime)(identity.pid);
+	if (currentStartTime !== identity.startTime) throw new Error("owner_pid_identity_mismatch");
+	const now = deps.now ?? (() => new Date());
+	const sleep = deps.sleep ?? (ms => Bun.sleep(ms));
+	const dispatchId = crypto.randomUUID();
+	await closeExactTmuxOwner(
+		{
+			stateDir: identity.stateDir,
+			sessionId: identity.sessionId,
+			generation: identity.generation,
+			serverKey: identity.socketKey,
+			pid: identity.pid,
+			startTime: identity.startTime,
+			dispatchId,
+			createdAt: now().toISOString(),
+			expiresAt: new Date(now().getTime() + FORCE_CLOSE_VERDICT_TIMEOUT_MS).toISOString(),
+		},
+		{
+			readStartTime: deps.readProcessStartTime ?? readProcessStartTime,
+			sendSigterm: async pid => {
+				if ((await (deps.readProcessStartTime ?? readProcessStartTime)(pid)) !== identity.startTime)
+					throw new Error("owner_pid_identity_mismatch");
+				(deps.signalTerm ?? (target => process.kill(target, "SIGTERM")))(pid);
+			},
+
+			waitForVerdict: () => waitForExpectedVerdict(identity, sleep, now),
+			cleanupSession: async () => {
+				await requireUnchangedOwnerForCompatibilityCleanup(
+					session.name,
+					nativeSessionId,
+					env,
+					identity,
+					actualStateFile,
+					initialServer,
+					deps.listPanePids ?? readExactSessionPanePids,
+					deps.readProcessStartTime ?? readProcessStartTime,
+				);
+				if (deps.cleanupSession) deps.cleanupSession(nativeSessionId, env);
+				else
+					runGuardedTmuxSessionCommand(
+						nativeSessionId,
+						session.name,
+						initialServer.pid,
+						env,
+						`kill-session -t '${nativeSessionId}'`,
+					);
+			},
+		},
+	);
 	return session;
 }
 
 export function attachSkcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): never {
+	if (resolveSkcTmuxBinary({ env }).isPsmux) throw new Error(`skc_tmux_owner_unverifiable:${sessionName}`);
 	const session = statusSkcTmuxSession(sessionName, env);
 	const tmuxCommand = resolveSkcTmuxCommand(env);
+	requireSafeTmuxServerForMutation(tmuxCommand, env);
 	const result = Bun.spawnSync(
 		[tmuxCommand, "attach-session", "-t", buildSkcTmuxExactSessionTarget(session.name, { env })],
 		{