@gajae-code/coding-agent 0.15.4 → 0.15.5

package/src/extensibility/extensions/types.ts

@@ -536,6 +536,7 @@ export interface ExtensionContext {
 			onPreflightAcceptCommit?: () => void | Promise<void>;
 			onSkillPrepared?: (meta: { name: string; path: string; lineCount?: number; cleanedArgs?: string }) => void;
 			preflightSignal?: AbortSignal;
+			sdkRunToken?: string;
 		},
 	): Promise<unknown>;
 	setPlanMode?(on: boolean): unknown;
@@ -754,6 +755,8 @@ export interface AgentStartEvent extends SharedAgentStartEvent {
 export interface AgentFailedEvent {
 	type: "agent_failed";
 	error: AgentFailureDiagnostic;
+	/** Internal SDK queue-owner binding for exact lifecycle attribution. */
+	sdkRunToken?: string;
 	/** Attempt correlation for the failing run, when scoped (matches the
 	 * agent_start/agent_end scope contract). */
 	scope?: AttemptScope;

package/src/extensibility/shared-events.ts

@@ -184,6 +184,8 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
 	type: "agent_end";
 	messages: AgentMessage[];
+	/** Internal SDK queue-owner binding for exact lifecycle attribution. */
+	sdkRunToken?: string;
 	/** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
 	stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
 	/** Present for maintenance checkpoints; non-aborted checkpoints are not terminal. */

package/src/gjc-runtime/launch-worktree.ts

@@ -78,7 +78,7 @@ const WORKTREE_BUCKET_ENV = "GJC_WORKTREE_DIR";
  * what keeps two repositories that share a branch name from resolving to one worktree.
  */
 const REPO_NAME_PLACEHOLDER = "{repo}";
-const DEFAULT_WORKTREE_BUCKET = `${REPO_NAME_PLACEHOLDER}.gajae-code-worktrees`;
+const DEFAULT_WORKTREE_BUCKET = `${REPO_NAME_PLACEHOLDER}/.worktrees`;
 
 function expandHomePrefix(value: string, home: string, pathApi: typeof path.posix): string {
 	if (value === "~") return home;
@@ -108,14 +108,36 @@ export function resolveWorktreeBucketForPath(
 /**
  * Directory that holds this repository's launch worktrees.
  *
- * A relative override resolves against the repository's PARENT directory, matching the
- * default's own shape, so `{repo}.worktrees` adopts an existing sibling bucket and
- * `.worktrees` parks a hidden bucket beside the repository. An absolute override is used verbatim.
+ * A relative override resolves against the repository's parent directory. The default
+ * `{repo}/.worktrees` template places managed worktrees inside the repository, while
+ * `{repo}.worktrees` adopts an existing sibling bucket. An absolute override is used verbatim.
  */
 function resolveWorktreeBucket(repoRoot: string): string {
 	return resolveWorktreeBucketForPath(repoRoot, process.env[WORKTREE_BUCKET_ENV], os.homedir(), path);
 }
 
+function ensureRepositoryBucketIgnored(repoRoot: string, bucketPath: string): void {
+	const relativeBucket = path.relative(repoRoot, bucketPath);
+	if (relativeBucket.startsWith(`..${path.sep}`) || relativeBucket === ".." || path.isAbsolute(relativeBucket)) return;
+	const ignoreProbe = path.join(relativeBucket, ".gjc-worktree-probe");
+	for (const candidate of [relativeBucket, ignoreProbe]) {
+		const result = Bun.spawnSync(["git", "check-ignore", "--quiet", "--", candidate], {
+			cwd: repoRoot,
+			stdout: "ignore",
+			stderr: "pipe",
+		});
+		if (result.exitCode === 0) return;
+	}
+	throw new Error(
+		[
+			"worktree_bucket_not_ignored",
+			"The GJC launch worktree bucket is inside the repository but is not ignored by Git.",
+			`Path: ${formatBucketPath(bucketPath)}`,
+			`Safe remediation: add /${relativeBucket.replaceAll(path.sep, "/")} to ${path.join(repoRoot, ".gitignore")}, then relaunch.`,
+		].join("\n"),
+	);
+}
+
 function resolveSourceBranchSlug(repoRoot: string, baseRef: string): string {
 	const branch = tryRunGit(repoRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
 	if (branch) return sanitizePathToken(branch);
@@ -301,6 +323,7 @@ function pruneStaleWorktreePath(repoRoot: string): void {
 
 function readWorktreeEntryFromPath(repoRoot: string, worktreePath: string): GitWorktreeEntry | null {
 	if (!fs.existsSync(worktreePath)) return null;
+	if (!fs.existsSync(path.join(worktreePath, ".git"))) return null;
 	const repoCommonDir = tryRunGit(repoRoot, ["rev-parse", "--git-common-dir"]);
 	const worktreeCommonDir = tryRunGit(worktreePath, ["rev-parse", "--git-common-dir"]);
 	if (!repoCommonDir || !worktreeCommonDir) return null;
@@ -379,6 +402,7 @@ export function planLaunchWorktree(
 	if (branchName) validateBranchName(repoRoot, branchName);
 	const worktreeSlug = mode.detached ? resolveSourceBranchSlug(repoRoot, baseRef) : sanitizePathToken(mode.name);
 	const worktreePath = path.join(resolveWorktreeBucket(repoRoot), worktreeSlug);
+	if (path.resolve(worktreePath) === path.resolve(repoRoot)) throw new Error(`worktree_path_conflict:${worktreePath}`);
 	return { enabled: true, repoRoot, worktreePath, detached: mode.detached, baseRef, branchName };
 }
 
@@ -386,6 +410,9 @@ export function ensureLaunchWorktree(
 	plan: GjcLaunchWorktreePlan | { enabled: false },
 ): GjcLaunchWorktreeResult | { enabled: false } {
 	if (!plan.enabled) return { enabled: false };
+	const bucketPath = path.dirname(plan.worktreePath);
+	inspectBucketDir(bucketPath);
+	ensureRepositoryBucketIgnored(plan.repoRoot, bucketPath);
 	let allWorktrees = listWorktrees(plan.repoRoot);
 	const staleAtPath = findWorktreeByPath(allWorktrees, plan.worktreePath);
 	if (staleAtPath && !fs.existsSync(staleAtPath.path)) {
@@ -393,9 +420,19 @@ export function ensureLaunchWorktree(
 		allWorktrees = listWorktrees(plan.repoRoot);
 	}
 
-	const existingAtPath =
-		findWorktreeByPath(allWorktrees, plan.worktreePath) ??
-		readWorktreeEntryFromPath(plan.repoRoot, plan.worktreePath);
+	const listedAtPath = findWorktreeByPath(allWorktrees, plan.worktreePath);
+	const existingAtPath = readWorktreeEntryFromPath(plan.repoRoot, plan.worktreePath);
+	if (listedAtPath && !existingAtPath) {
+		if (fs.existsSync(plan.worktreePath)) throw new Error(`worktree_path_conflict:${plan.worktreePath}`);
+		throw new Error(
+			[
+				"worktree_path_unavailable",
+				"The requested launch worktree is still registered by Git but its directory is unavailable or locked.",
+				`Path: ${formatBucketPath(plan.worktreePath)}`,
+				"Safe remediation: inspect the worktree lock and remove or repair it with git worktree remove/prune when it is no longer needed, then relaunch. GJC did not delete or replace the entry.",
+			].join("\n"),
+		);
+	}
 	const expectedBranchRef = plan.branchName ? `refs/heads/${plan.branchName}` : null;
 
 	if (existingAtPath) {

package/src/gjc-runtime/ralplan-runtime.ts

@@ -756,9 +756,22 @@ export async function resolveRalplanTargetRoot(
 		stdout: "pipe",
 		stderr: "pipe",
 	});
-	if ((await verified.exited) !== 0) {
+	const [verifiedStatus, verifiedOutput] = await Promise.all([verified.exited, new Response(verified.stdout).text()]);
+	const headObject = verifiedOutput.trim();
+	if (verifiedStatus !== 0 || !/^[0-9a-f]{40,64}$/u.test(headObject)) {
 		throw new RalplanCommandError(2, `ralplan --worktree-root is not a valid git worktree: ${canonical}`);
 	}
+	const objectType = Bun.spawn(["git", "-C", canonical, "cat-file", "-t", headObject], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [objectTypeStatus, objectTypeOutput] = await Promise.all([
+		objectType.exited,
+		new Response(objectType.stdout).text(),
+	]);
+	if (objectTypeStatus !== 0 || objectTypeOutput.trim() !== "commit") {
+		throw new RalplanCommandError(2, `ralplan --worktree-root is not a commit worktree: ${canonical}`);
+	}
 	let worktreeRoot: string;
 	try {
 		worktreeRoot = await fs.realpath(repository.repoRoot);

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

@@ -153,6 +153,8 @@ export interface ForceCloseOwnerDependencies {
 	waitForOwnerExitVerdict?(): Promise<OwnerVerdict>;
 }
 const GJC_TMUX_PSMUX_INCARNATION_OPTION = "@gjc-psmux-incarnation";
+const effectiveSessionEnvironments = new WeakMap<GjcTmuxSessionStatus, NodeJS.ProcessEnv>();
+const fallbackSessionEnvironments = new WeakSet<GjcTmuxSessionStatus>();
 
 const FORCE_CLOSE_VERDICT_TIMEOUT_MS = 15_000;
 const FORCE_CLOSE_VERDICT_POLL_MS = 50;
@@ -305,20 +307,79 @@ function parseSessionLine(line: string): GjcTmuxSessionStatus | null {
 	};
 }
 
-function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env): string[] {
+/** tmux failure shapes that mean "this socket has no server", not "tmux is broken". */
+function isMissingServerFailure(message: string): boolean {
+	return (
+		message.includes("no server running") ||
+		(message.includes("failed to connect to server") && /(?:no such file or directory|not found)/iu.test(message))
+	);
+}
+
+function isMissingSocketFailure(message: string): boolean {
+	return (
+		message.toLowerCase().includes("error connecting to ") &&
+		/(?:no such file or directory|not found)/iu.test(message)
+	);
+}
+
+/**
+ * `$TMUX` is inherited from whatever launched gjc and names the socket tmux
+ * talks to. Terminal hosts that emulate tmux for their own agents can export a
+ * `$TMUX` pointing at a socket they never created, and tmux then fails with
+ * `error connecting to <socket>` — the same message shape as a legitimate
+ * "no server" miss. Returning the socket path lets callers tell the two apart
+ * instead of reporting zero sessions while sessions are live on the default
+ * socket.
+ */
+function inheritedTmuxSocketPath(env: NodeJS.ProcessEnv): string | null {
+	const socket = env.TMUX?.split(",")[0]?.trim();
+	return socket ? socket : null;
+}
+
+function namesInheritedTmuxSocket(message: string, socket: string): boolean {
+	const normalizedMessage = process.platform === "win32" ? message.toLowerCase() : message;
+	const normalizedSocket = process.platform === "win32" ? socket.toLowerCase() : socket;
+	return (
+		(normalizedMessage.includes(`error connecting to ${normalizedSocket} `) ||
+			normalizedMessage.includes(`failed to connect to server: ${normalizedSocket} `)) &&
+		/(?:no such file or directory|not found)/iu.test(message)
+	);
+}
+
+function envWithoutInheritedTmux(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	const withoutTmux: NodeJS.ProcessEnv = { ...env };
+	delete withoutTmux.TMUX;
+	return withoutTmux;
+}
+
+interface ListedTmuxSessions {
+	lines: string[];
+	env: NodeJS.ProcessEnv;
+}
+
+function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env): ListedTmuxSessions {
+	let effectiveEnv = env;
 	let output = "";
 	try {
 		output = runTmux(["list-sessions", "-F", format], env);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		if (
-			message.includes("no server running") ||
-			message.includes("failed to connect to server") ||
-			message.includes("error connecting to")
-		) {
-			return [];
-		}
-		throw error;
+		const inheritedSocket = inheritedTmuxSocketPath(env);
+		// A miss on the default socket is a real empty list; only the inherited
+		// socket is suspect, so retry without it before concluding there is
+		// nothing to list.
+		if (inheritedSocket && namesInheritedTmuxSocket(message, inheritedSocket)) {
+			try {
+				effectiveEnv = envWithoutInheritedTmux(env);
+				output = runTmux(["list-sessions", "-F", format], effectiveEnv);
+			} catch (retryError) {
+				const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+				if (isMissingServerFailure(retryMessage) || isMissingSocketFailure(retryMessage))
+					return { lines: [], env: effectiveEnv };
+				throw retryError;
+			}
+		} else if (isMissingServerFailure(message) || isMissingSocketFailure(message)) return { lines: [], env };
+		else throw error;
 	}
 	const lines = output
 		.split("\n")
@@ -333,20 +394,25 @@ function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env):
 	if (lines.length > 0 && !lines[0].includes("\t")) {
 		const binary = resolveGjcTmuxBinary({ env });
 		if (binary.isPsmux) {
-			return lines.map(line => {
-				const match = line.match(/^([^:]+):\s*(\d+)\s+windows?\s+\(created\s+([^)]+)\)/);
-				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 {
+				lines: lines.map(line => {
+					const match = line.match(/^([^:]+):\s*(\d+)\s+windows?\s+\(created\s+([^)]+)\)/);
+					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",
+					);
+				}),
+				env: effectiveEnv,
+			};
 		}
 	}
-	return lines;
+	return { lines, env: effectiveEnv };
 }
 
-function listSessionLines(env: NodeJS.ProcessEnv = process.env): string[] {
+function listSessionLines(env: NodeJS.ProcessEnv = process.env): ListedTmuxSessions {
 	return runListSessions(
 		`#{session_name}\t#{session_windows}\t#{session_attached}\t#{session_created}\t#{${GJC_TMUX_PROFILE_OPTION}}\t#{session_key_table}\t#{session_panes}\t#{pane_pid}\t#{${GJC_TMUX_BRANCH_OPTION}}\t#{${GJC_TMUX_BRANCH_SLUG_OPTION}}\t#{${GJC_TMUX_PROJECT_OPTION}}\t#{${GJC_TMUX_SESSION_ID_OPTION}}\t#{${GJC_TMUX_SESSION_STATE_FILE_OPTION}}\t#{${GJC_TMUX_OWNER_GENERATION_OPTION}}\t#{${GJC_TMUX_VERSION_OPTION}}\t#{${GJC_TMUX_PSMUX_INCARNATION_OPTION}}\t#{session_id}`,
 
@@ -355,8 +421,13 @@ function listSessionLines(env: NodeJS.ProcessEnv = process.env): string[] {
 }
 
 function listRawTmuxSessionNames(env: NodeJS.ProcessEnv = process.env): string[] {
-	return runListSessions("#{session_name}", env).map(line => line.split("\t")[0] ?? line);
+	return runListSessions("#{session_name}", env).lines.map(line => line.split("\t")[0] ?? line);
+}
+
+function assertMutationAuthority(session: GjcTmuxSessionStatus): void {
+	if (fallbackSessionEnvironments.has(session)) throw new Error("gjc_tmux_fallback_authority_unconfirmed");
 }
+
 function canonicalProviderStateDirs(cwd: string): string[] {
 	const gjcDir = path.join(cwd, GJC_DIR);
 	let entries: fsSync.Dirent[];
@@ -424,13 +495,24 @@ function psmuxAuthorityEnvironments(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv[]
 
 export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus[] {
 	const discovered = psmuxAuthorityEnvironments(env).flatMap(authorityEnv => {
-		const authority = psmuxAuthorityFromEnv(authorityEnv) ?? undefined;
-		return listSessionLines(authorityEnv)
+		const listed = listSessionLines(authorityEnv);
+		const authority = psmuxAuthorityFromEnv(listed.env) ?? undefined;
+		return listed.lines
 			.map(parseSessionLine)
 			.filter((session): session is GjcTmuxSessionStatus => session != null)
-			.map(session => hydrateSessionFromExactOptions(session, authorityEnv))
+			.map(session => {
+				const hydrated = hydrateSessionFromExactOptions(session, listed.env);
+				effectiveSessionEnvironments.set(hydrated, listed.env);
+				if (listed.env !== authorityEnv) fallbackSessionEnvironments.add(hydrated);
+				return hydrated;
+			})
 			.filter((session): session is GjcTmuxSessionStatus => session?.profile === GJC_TMUX_PROFILE_VALUE)
-			.map(session => (authority ? { ...session, providerAuthority: authority } : session));
+			.map(session => {
+				const result = authority ? { ...session, providerAuthority: authority } : session;
+				effectiveSessionEnvironments.set(result, listed.env);
+				if (listed.env !== authorityEnv) fallbackSessionEnvironments.add(result);
+				return result;
+			});
 	});
 	const names = new Set<string>();
 	for (const session of discovered) {
@@ -443,12 +525,18 @@ export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTm
 /** @internal */
 export function listTmuxSessionsForGc(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionsForGc {
 	const authorityEnvironments = psmuxAuthorityEnvironments(env);
-	const sessions = authorityEnvironments.flatMap(authorityEnv =>
-		listSessionLines(authorityEnv)
+	const sessions = authorityEnvironments.flatMap(authorityEnv => {
+		const listed = listSessionLines(authorityEnv);
+		return listed.lines
 			.map(parseSessionLine)
 			.filter((session): session is GjcTmuxSessionStatus => session != null)
-			.map(session => hydrateSessionFromExactOptions(session, authorityEnv)),
-	);
+			.map(session => {
+				const hydrated = hydrateSessionFromExactOptions(session, listed.env);
+				effectiveSessionEnvironments.set(hydrated, listed.env);
+				if (listed.env !== authorityEnv) fallbackSessionEnvironments.add(hydrated);
+				return hydrated;
+			});
+	});
 	const tagged = sessions
 		.filter(session => session.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
@@ -1148,17 +1236,18 @@ export function readTmuxSessionTagsForGc(
 	env: NodeJS.ProcessEnv = process.env,
 ): GjcTmuxSessionTagsForGc {
 	const session = listGjcTmuxSessions(env).find(candidate => candidate.name === sessionName);
+	const sessionEnv = session ? (effectiveSessionEnvironments.get(session) ?? env) : env;
 	return {
-		profile: readExactOptionForGc(sessionName, GJC_TMUX_PROFILE_OPTION, env),
-		project: readExactOptionForGc(sessionName, GJC_TMUX_PROJECT_OPTION, env),
-		psmuxIncarnation: readExactOptionForGc(sessionName, GJC_TMUX_PSMUX_INCARNATION_OPTION, env),
-		branch: readExactOptionForGc(sessionName, GJC_TMUX_BRANCH_OPTION, env),
-		branchSlug: readExactOptionForGc(sessionName, GJC_TMUX_BRANCH_SLUG_OPTION, env),
-		sessionId: readExactOptionForGc(sessionName, GJC_TMUX_SESSION_ID_OPTION, env),
-		sessionStateFile: readExactOptionForGc(sessionName, GJC_TMUX_SESSION_STATE_FILE_OPTION, env),
-		version: readExactOptionForGc(sessionName, GJC_TMUX_VERSION_OPTION, env),
-		ownerGeneration: readExactOptionForGc(sessionName, GJC_TMUX_OWNER_GENERATION_OPTION, env),
-		nativeSessionId: session?.nativeSessionId ?? readNativeTmuxSessionId(sessionName, env),
+		profile: readExactOptionForGc(sessionName, GJC_TMUX_PROFILE_OPTION, sessionEnv),
+		project: readExactOptionForGc(sessionName, GJC_TMUX_PROJECT_OPTION, sessionEnv),
+		psmuxIncarnation: readExactOptionForGc(sessionName, GJC_TMUX_PSMUX_INCARNATION_OPTION, sessionEnv),
+		branch: readExactOptionForGc(sessionName, GJC_TMUX_BRANCH_OPTION, sessionEnv),
+		branchSlug: readExactOptionForGc(sessionName, GJC_TMUX_BRANCH_SLUG_OPTION, sessionEnv),
+		sessionId: readExactOptionForGc(sessionName, GJC_TMUX_SESSION_ID_OPTION, sessionEnv),
+		sessionStateFile: readExactOptionForGc(sessionName, GJC_TMUX_SESSION_STATE_FILE_OPTION, sessionEnv),
+		version: readExactOptionForGc(sessionName, GJC_TMUX_VERSION_OPTION, sessionEnv),
+		ownerGeneration: readExactOptionForGc(sessionName, GJC_TMUX_OWNER_GENERATION_OPTION, sessionEnv),
+		nativeSessionId: session?.nativeSessionId ?? readNativeTmuxSessionId(sessionName, sessionEnv),
 		createdAt: session?.createdAt,
 		attached: session?.attached,
 		panePids: session?.panePids,
@@ -1171,6 +1260,9 @@ export function removeGjcTmuxSession(
 	expectedIdentity?: ExpectedGjcTmuxSessionIdentity,
 ): GjcTmuxSessionStatus {
 	const session = statusGjcTmuxSession(sessionName, env);
+	assertMutationAuthority(session);
+	const sessionEnv =
+		effectiveSessionEnvironments.get(session) ?? environmentForProviderAuthority(env, session.providerAuthority);
 	if (session.attached || session.panePids.length > 0) {
 		throw new Error(`gjc_tmux_session_live:${sessionName}`);
 	}
@@ -1185,32 +1277,33 @@ export function removeGjcTmuxSession(
 			session.createdAt !== expectedIdentity.createdAt)
 	)
 		throw new Error(`gjc_tmux_owner_changed:${sessionName}`);
-	if (readProfileForExactTarget(session.name, env) !== GJC_TMUX_PROFILE_VALUE) {
+	if (readProfileForExactTarget(session.name, sessionEnv) !== GJC_TMUX_PROFILE_VALUE) {
 		throw new Error(`gjc_tmux_session_not_managed:${sessionName}`);
 	}
-	const nativeSessionId = readNativeTmuxSessionId(session.name, env);
+	const nativeSessionId = readNativeTmuxSessionId(session.name, sessionEnv);
 	if (!nativeSessionId) throw new Error(`gjc_tmux_owner_unverifiable:${sessionName}`);
 	if (expectedIdentity && nativeSessionId !== expectedIdentity.nativeSessionId)
 		throw new Error(`gjc_tmux_owner_changed:${sessionName}`);
 	if (
 		expectedIdentity &&
-		readExactOptionForGc(session.name, GJC_TMUX_OWNER_GENERATION_OPTION, env) !== expectedIdentity.ownerGeneration
+		readExactOptionForGc(session.name, GJC_TMUX_OWNER_GENERATION_OPTION, sessionEnv) !==
+			expectedIdentity.ownerGeneration
 	)
 		throw new Error(`gjc_tmux_owner_changed:${sessionName}`);
-	const firstServer = requireSafeTmuxServerForMutation(resolveGjcTmuxCommand(env), env);
+	const firstServer = requireSafeTmuxServerForMutation(resolveGjcTmuxCommand(sessionEnv), sessionEnv);
 	if (
-		readNativeTmuxSessionId(nativeSessionId, env) !== nativeSessionId ||
-		readProfileForExactTarget(nativeSessionId, env) !== GJC_TMUX_PROFILE_VALUE
+		readNativeTmuxSessionId(nativeSessionId, sessionEnv) !== nativeSessionId ||
+		readProfileForExactTarget(nativeSessionId, sessionEnv) !== GJC_TMUX_PROFILE_VALUE
 	)
 		throw new Error(`gjc_tmux_owner_changed:${sessionName}`);
-	const finalServer = requireSafeTmuxServerForMutation(resolveGjcTmuxCommand(env), env);
+	const finalServer = requireSafeTmuxServerForMutation(resolveGjcTmuxCommand(sessionEnv), sessionEnv);
 	if (finalServer.pid !== firstServer.pid || finalServer.startTime !== firstServer.startTime)
 		throw new Error(`gjc_tmux_owner_changed:${sessionName}`);
 	runGuardedTmuxSessionCommand(
 		nativeSessionId,
 		session.name,
 		finalServer,
-		env,
+		sessionEnv,
 		`kill-session -t '${nativeSessionId}'`,
 		expectedIdentity?.ownerGeneration,
 	);
@@ -1426,7 +1519,9 @@ export async function forceCloseGjcTmuxSession(
 	deps: Partial<ForceCloseOwnerDependencies> = {},
 ): Promise<GjcTmuxSessionStatus> {
 	const session = statusGjcTmuxSession(sessionName, env);
-	const sessionEnv = environmentForProviderAuthority(env, session.providerAuthority);
+	assertMutationAuthority(session);
+	const sessionEnv =
+		effectiveSessionEnvironments.get(session) ?? environmentForProviderAuthority(env, session.providerAuthority);
 	if (readProfileForExactTarget(session.name, sessionEnv) !== GJC_TMUX_PROFILE_VALUE)
 		throw new Error(`gjc_tmux_session_not_managed:${sessionName}`);
 	const exactPanePids = (deps.listPanePids ?? readExactSessionPanePids)(session.name, sessionEnv);
@@ -1560,7 +1655,9 @@ export async function forceCloseGjcTmuxSession(
 
 export function attachGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): never {
 	const session = statusGjcTmuxSession(sessionName, env);
-	const sessionEnv = environmentForProviderAuthority(env, session.providerAuthority);
+	assertMutationAuthority(session);
+	const sessionEnv =
+		effectiveSessionEnvironments.get(session) ?? environmentForProviderAuthority(env, session.providerAuthority);
 	const authority = session.providerAuthority ?? psmuxAuthorityFromEnv(sessionEnv);
 	const tmuxCommand = authority?.command ?? resolveGjcTmuxCommand(sessionEnv);
 	if (authority) assertGjcTmuxMutationAuthoritySync(authority);