@gajae-code/coding-agent 0.12.5 → 0.12.6

package/src/gjc-runtime/managed-owner-supervisor.ts

@@ -92,6 +92,10 @@ function lifecycleRoot(): {
 function commandDigest(command: readonly string[]): string {
 	return crypto.createHash("sha256").update(JSON.stringify(command)).digest("hex");
 }
+async function managedOwnerProcessProvenance(pid: number): Promise<string | null> {
+	if (process.platform === "linux") return await readLinuxProcStartTime(pid);
+	return Process.fromPid(pid)?.incarnation ?? null;
+}
 
 async function writeDurableExclusive(file: string, value: object): Promise<void> {
 	const handle = await fs.open(file, "wx", 0o600);
@@ -132,7 +136,7 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 	};
 	process.removeAllListeners("SIGTERM");
 	process.on("SIGTERM", captureEarlySigterm);
-	const supervisorStartTime = await readLinuxProcStartTime(process.pid);
+	const supervisorStartTime = await managedOwnerProcessProvenance(process.pid);
 	if (!supervisorStartTime) throw new Error("managed_owner_supervisor_start_time_unavailable");
 	await fs.mkdir(root, { recursive: true, mode: 0o700 });
 	const childToken = crypto.randomUUID();
@@ -157,7 +161,7 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 		stderr: "inherit",
 		env: { ...process.env, [MANAGED_OWNER_CHILD_TOKEN_ENV]: childToken },
 	});
-	const childStartTime = await readLinuxProcStartTime(child.pid);
+	const childStartTime = await managedOwnerProcessProvenance(child.pid);
 	if (!childStartTime) throw new Error("managed_owner_child_start_time_unavailable");
 	const childProcess = Process.fromPid(child.pid);
 	if (!childProcess) throw new Error("managed_owner_child_reference_unavailable");

package/src/gjc-runtime/psmux-detect.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 
 /**
@@ -62,8 +63,32 @@ export type ExecutableIdentityResolver = (path: string) => string | null;
 const DEFAULT_EXECUTABLE_IDENTITY_RESOLVER: ExecutableIdentityResolver = executablePath => {
 	try {
 		const realPath = fs.realpathSync.native(executablePath);
-		const stat = fs.statSync(realPath);
-		return stat.ino === 0 ? realPath.toLowerCase() : `${stat.dev}:${stat.ino}`;
+		const fd = fs.openSync(realPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+		try {
+			const before = fs.fstatSync(fd, { bigint: true });
+			if (!before.isFile() || before.dev === 0n || before.ino === 0n) return null;
+			const bytes = fs.readFileSync(fd);
+			const after = fs.fstatSync(fd, { bigint: true });
+			const named = fs.lstatSync(realPath, { bigint: true });
+			if (
+				!named.isFile() ||
+				named.isSymbolicLink() ||
+				after.dev !== before.dev ||
+				after.ino !== before.ino ||
+				after.size !== before.size ||
+				after.mtimeNs !== before.mtimeNs ||
+				after.ctimeNs !== before.ctimeNs ||
+				named.dev !== before.dev ||
+				named.ino !== before.ino ||
+				named.size !== before.size ||
+				named.mtimeNs !== before.mtimeNs ||
+				named.ctimeNs !== before.ctimeNs
+			)
+				return null;
+			return `${before.dev}:${before.ino}:${before.size}:${before.mtimeNs}:${before.ctimeNs}:${createHash("sha256").update(bytes).digest("hex")}`;
+		} finally {
+			fs.closeSync(fd);
+		}
 	} catch {
 		return null;
 	}
@@ -152,6 +177,14 @@ function isNamedPsmuxCommand(command: string): boolean {
 function resolveBinaryPath(candidate: string): string | null {
 	return activeBinaryResolver(candidate);
 }
+/** Resolve through the same identity-aware seams used by Windows alias detection. */
+export function resolveGjcTmuxExecutablePath(command: string): string | null {
+	return resolveBinaryPath(command);
+}
+
+export function resolveGjcTmuxExecutableIdentity(executablePath: string): string | null {
+	return activeExecutableIdentityResolver(executablePath);
+}
 
 function detectPsmuxForCommand(command: string, runner: PsmuxSpawnRunner): boolean {
 	const resolved = resolveBinaryPath(command);
@@ -291,11 +324,24 @@ export function resolveGjcTmuxBinary(options: ResolveGjcTmuxBinaryOptions = {}):
 		return { command: explicit, isPsmux, viaExplicitOverride: true };
 	}
 	if (platform === "win32") {
+		const candidates: Array<{ command: string; identity: string }> = [];
 		for (const candidate of PSMUX_BINARY_NAMES) {
-			if (resolveBinaryPath(candidate)) {
-				const isPsmux = classifyWindowsTmuxAlias(candidate, env, runner);
-				return { command: candidate, isPsmux, viaExplicitOverride: false };
-			}
+			const executablePath = resolveBinaryPath(candidate);
+			if (!executablePath) continue;
+			const isPsmuxAlias = candidate !== "tmux" || detectPsmuxForCommand(candidate, runner);
+			if (!isPsmuxAlias) continue;
+			const identity = activeExecutableIdentityResolver(executablePath);
+			if (!identity)
+				throw new Error(`gjc_tmux_provider_ambiguous: Windows ${candidate} executable identity is unavailable`);
+			candidates.push({ command: candidate, identity });
+		}
+		if (candidates.length > 0) {
+			const identities = new Set(candidates.map(candidate => candidate.identity));
+			if (identities.size !== 1)
+				throw new Error("gjc_tmux_provider_ambiguous: Windows psmux aliases resolve to different executables");
+			// The order is the canonical provider spelling, then its compatibility
+			// aliases. Identity equality above makes PATH-order alias selection safe.
+			return { command: candidates[0]!.command, isPsmux: true, viaExplicitOverride: false };
 		}
 	}
 	const tmuxPath = resolveBinaryPath("tmux");

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

@@ -2,6 +2,11 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { SPAWN_PROVENANCE_ENV } from "../sdk/bus/config";
 import { resolveSessionIdFromSources } from "./session-resolution";
+import {
+	GJC_COORDINATOR_SESSION_ID_ENV,
+	GJC_TMUX_OWNER_GENERATION_ENV,
+	GJC_TMUX_OWNER_STATE_DIR_ENV,
+} from "./session-state-sidecar";
 import type {
 	GjcTeamConfig,
 	GjcTeamSnapshot,
@@ -13,6 +18,12 @@ import type {
 	GjcTeamWorktreeMode,
 } from "./team-runtime";
 import { createInitialGjcTeamWorkerMemoryGuardLedger, workerMemoryGuardLedgerPath } from "./team-worker-memory-guard";
+import {
+	bindGjcTmuxProviderAuthority,
+	type ProviderAuthority,
+	readGjcTmuxProviderAuthoritySync,
+	resolveGjcTmuxProviderContext,
+} from "./tmux-provider-context";
 
 /** Launch-specific option wiring kept separate from runtime dispatch. */
 export function withTeamLaunchTransport(
@@ -97,6 +108,7 @@ export function buildWorkerCommand(
 interface GjcTmuxBinary {
 	command: string;
 	isPsmux: boolean;
+	viaExplicitOverride: boolean;
 }
 
 interface GjcTmuxLeaderContext {
@@ -115,7 +127,11 @@ export interface GjcTeamLaunchRuntime {
 	teamDir(stateRoot: string, teamName: string): string;
 	resolveDefaultWorktreeMode(mode?: GjcTeamWorktreeMode): GjcTeamWorktreeMode;
 	resolveTmuxBinary(input: { env: NodeJS.ProcessEnv; platform: NodeJS.Platform }): GjcTmuxBinary;
-	readTmuxLeaderContext(tmuxCommand: string, env: NodeJS.ProcessEnv): GjcTmuxLeaderContext;
+	readTmuxLeaderContext(
+		tmuxCommand: string,
+		env: NodeJS.ProcessEnv,
+		authority: ProviderAuthority,
+	): GjcTmuxLeaderContext;
 	buildWorkers(workerCount: number, agentType: string, stateRoot: string): GjcTeamWorker[];
 	buildInitialTasks(task: string, workers: GjcTeamWorker[]): GjcTeamTask[];
 	ensureWorkerWorktree(
@@ -217,9 +233,32 @@ export async function startGjcTeamLaunch(
 	const platform = options.platform ?? process.platform;
 	const tmuxBinary = runtime.resolveTmuxBinary({ env, platform });
 	const tmuxCommand = tmuxBinary.command;
+	const tmuxProviderGeneration =
+		tmuxBinary.isPsmux && platform === "win32" ? env[GJC_TMUX_OWNER_GENERATION_ENV]?.trim() : undefined;
+	const tmuxProvider = resolveGjcTmuxProviderContext({ binary: tmuxBinary, env, platform });
+	if (tmuxProvider.binary.command !== tmuxCommand) throw new Error("gjc_team_tmux_provider_command_mismatch");
+	const launchSessionId =
+		env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || env.GJC_SESSION_ID?.trim() || gjcSessionId?.trim();
+	const launchStateDir = env[GJC_TMUX_OWNER_STATE_DIR_ENV]?.trim();
+	const tmuxAuthority =
+		tmuxBinary.isPsmux && platform === "win32" && !options.dryRun
+			? launchSessionId && launchStateDir && tmuxProviderGeneration
+				? readGjcTmuxProviderAuthoritySync({
+						stateDir: launchStateDir,
+						sessionId: launchSessionId,
+						generation: tmuxProviderGeneration,
+					})
+				: (() => {
+						throw new Error("gjc_team_tmux_provider_authority_unavailable");
+					})()
+			: bindGjcTmuxProviderAuthority(tmuxProvider, {
+					stateDir: stateRoot,
+					sessionId: teamName,
+					generation: "native-tmux",
+				});
 	const tmuxContext = options.dryRun
 		? { sessionName: "dry-run", windowIndex: "0", leaderPaneId: "%dry-run-leader", target: "dry-run:0" }
-		: runtime.readTmuxLeaderContext(tmuxCommand, env);
+		: runtime.readTmuxLeaderContext(tmuxCommand, env, tmuxAuthority);
 	const initialWorkers = runtime.buildWorkers(options.workerCount, options.agentType, stateRoot);
 	const initialTasks = runtime.buildInitialTasks(options.task, initialWorkers);
 	const workers: GjcTeamWorker[] = [];
@@ -267,9 +306,17 @@ export async function startGjcTeamLaunch(
 		...(gjcSessionId ? { gjc_session_id: gjcSessionId } : {}),
 		worker_cli_plan: workerCliPlan,
 		tmux_command: tmuxCommand,
+		platform,
 		tmux_session: tmuxContext.sessionName,
 		tmux_session_name: tmuxContext.sessionName,
 		tmux_target: tmuxContext.target,
+		...(tmuxProviderGeneration
+			? {
+					tmux_provider_generation: tmuxProviderGeneration,
+					tmux_provider_state_dir: launchStateDir!,
+					tmux_provider_session_id: launchSessionId!,
+				}
+			: {}),
 		workspace_mode: worktreeMode.enabled ? "worktree" : "direct",
 		dry_run: options.dryRun ?? false,
 		leader: {
@@ -296,6 +343,7 @@ export async function startGjcTeamLaunch(
 		worker_command: config.worker_command,
 		worker_cli_plan: config.worker_cli_plan,
 		tmux_command: config.tmux_command,
+		tmux_provider_generation: config.tmux_provider_generation,
 		leader: config.leader,
 		workers: config.workers,
 		workspace_mode: config.workspace_mode,