@gajae-code/coding-agent 0.9.6 → 0.10.0

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

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getWorktreesDir } from "@gajae-code/utils/dirs";
+import { SPAWN_PROVENANCE_ENV } from "../notifications/config";
 import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildTeamHudSummary as buildWorkflowTeamHudSummary } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
@@ -2083,6 +2084,11 @@ export function buildWorkerCommand(
 		envAssignment("GJC_TEAM_STATE_ROOT", config.state_root),
 		envAssignment("GJC_TEAM_LEADER_CWD", config.leader.cwd),
 		envAssignment("GJC_TEAM_DISPLAY_NAME", config.display_name),
+		// Canonical GJC spawn-provenance marker so `notifications.sessionScope =
+		// "primary"` suppresses the worker's own notification endpoint/topic. The
+		// value is informational (leader session id, falling back to the team name
+		// so it is always non-blank); presence is what marks the worker.
+		envAssignment(SPAWN_PROVENANCE_ENV, config.leader.session_id.trim() || config.team_name),
 		...(worker.worktree_path ? [envAssignment("GJC_TEAM_WORKTREE_PATH", worker.worktree_path)] : []),
 	];
 	const joined = platform === "win32" ? envLines.join(" ") : envLines.join(" ");

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

@@ -14,6 +14,9 @@ export const GJC_TMUX_BRANCH_SLUG_OPTION = "@gjc-branch-slug";
 export const GJC_TMUX_PROJECT_OPTION = "@gjc-project";
 export const GJC_TMUX_SESSION_ID_OPTION = "@gjc-session-id";
 export const GJC_TMUX_SESSION_STATE_FILE_OPTION = "@gjc-session-state-file";
+export const GJC_TMUX_OWNER_GENERATION_OPTION = "@gjc-owner-generation";
+export const GJC_TMUX_OWNER_SERVER_KEY_OPTION = "@gjc-owner-server-key";
+
 export const GJC_TMUX_VERSION_OPTION = "@gjc-version";
 export const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 
@@ -158,15 +161,13 @@ export function buildGjcTmuxRequiredProfileCommands(
 		project?: string | null;
 		sessionId?: string | null;
 		sessionStateFile?: string | null;
+		ownerGeneration?: string | null;
+		ownerServerKey?: string | null;
 		version?: string | null;
 	} = {},
 ): GjcTmuxProfileCommand[] {
-	const commands: GjcTmuxProfileCommand[] = [
-		{
-			description: "mark GJC tmux ownership",
-			args: ["set-option", "-t", target, GJC_TMUX_PROFILE_OPTION, GJC_TMUX_PROFILE_VALUE],
-		},
-	];
+	const commands: GjcTmuxProfileCommand[] = [];
+
 	if (metadata.branch)
 		commands.push({
 			description: "record GJC branch identity",
@@ -192,11 +193,26 @@ export function buildGjcTmuxRequiredProfileCommands(
 			description: "record GJC session state marker",
 			args: ["set-option", "-t", target, GJC_TMUX_SESSION_STATE_FILE_OPTION, metadata.sessionStateFile],
 		});
+	if (metadata.ownerGeneration)
+		commands.push({
+			description: "record GJC owner generation",
+			args: ["set-option", "-t", target, GJC_TMUX_OWNER_GENERATION_OPTION, metadata.ownerGeneration],
+		});
+	if (metadata.ownerServerKey)
+		commands.push({
+			description: "record GJC owner server key",
+			args: ["set-option", "-t", target, GJC_TMUX_OWNER_SERVER_KEY_OPTION, metadata.ownerServerKey],
+		});
+
 	if (metadata.version)
 		commands.push({
 			description: "record GJC version identity",
 			args: ["set-option", "-t", target, GJC_TMUX_VERSION_OPTION, metadata.version],
 		});
+	commands.push({
+		description: "mark GJC tmux ownership",
+		args: ["set-option", "-t", target, GJC_TMUX_PROFILE_OPTION, GJC_TMUX_PROFILE_VALUE],
+	});
 	return commands;
 }
 
@@ -219,6 +235,8 @@ export function buildGjcTmuxProfileCommands(
 		project?: string | null;
 		sessionId?: string | null;
 		sessionStateFile?: string | null;
+		ownerGeneration?: string | null;
+		ownerServerKey?: string | null;
 		version?: string | null;
 	} = {},
 	opts: { platform?: NodeJS.Platform; tmuxCommand?: string } = {},
@@ -260,7 +278,8 @@ export function buildGjcTmuxProfileCommands(
 		tmuxName.endsWith("/pmux") ||
 		tmuxName.endsWith("\\psmux") ||
 		tmuxName.endsWith("\\pmux");
-	const dropUx = isPsmuxClass && !envDisabled(env[GJC_PSMUX_PROFILE_FORCE_ENV]);
+	const forcePsmuxProfile = env[GJC_PSMUX_PROFILE_FORCE_ENV] === "true" || env[GJC_PSMUX_PROFILE_FORCE_ENV] === "1";
+	const dropUx = isPsmuxClass && !forcePsmuxProfile;
 	if (dropUx) {
 		return commands.filter(command => {
 			const flag = command.args[0];

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

@@ -22,6 +22,37 @@ const STORE = "tmux_sessions" as const;
 const TOCTOU_SKIP = "tmux_revalidation_failed_or_became_live";
 const ORPHAN_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
+type CollectedTmuxIdentity = {
+	nativeSessionId: string;
+	ownerGeneration: string;
+	sessionId: string;
+	sessionStateFile: string;
+	project: string;
+	createdAt: string;
+};
+
+const collectedIdentities = new WeakMap<GcRecord, CollectedTmuxIdentity>();
+
+function collectedIdentity(session: GjcTmuxSessionStatus): CollectedTmuxIdentity | undefined {
+	if (
+		!session.nativeSessionId ||
+		!session.ownerGeneration ||
+		!session.sessionId ||
+		!session.sessionStateFile ||
+		!session.project ||
+		!session.createdAt
+	)
+		return undefined;
+	return {
+		nativeSessionId: session.nativeSessionId,
+		ownerGeneration: session.ownerGeneration,
+		sessionId: session.sessionId,
+		sessionStateFile: session.sessionStateFile,
+		project: session.project,
+		createdAt: session.createdAt,
+	};
+}
+
 function pathExists(path: string): boolean {
 	try {
 		return fs.existsSync(path);
@@ -168,15 +199,21 @@ function classifyUntaggedSession(session: GjcTmuxSessionStatus): GcRecord {
 	return unclassifiedRecord(session.name, "untagged_tmux_session");
 }
 
-async function revalidateRemovable(record: GcRecord, env: NodeJS.ProcessEnv): Promise<boolean> {
+async function revalidateRemovable(
+	record: GcRecord,
+	identity: CollectedTmuxIdentity,
+	env: NodeJS.ProcessEnv,
+): Promise<boolean> {
 	const tags = readTmuxSessionTagsForGc(record.id, env);
 	if (
-		tags.createdAt &&
-		record.detail?.includes("createdAt=") &&
-		!record.detail.includes(`createdAt=${tags.createdAt}`)
-	) {
+		tags.nativeSessionId !== identity.nativeSessionId ||
+		tags.ownerGeneration !== identity.ownerGeneration ||
+		tags.sessionId !== identity.sessionId ||
+		tags.sessionStateFile !== identity.sessionStateFile ||
+		tags.project !== identity.project ||
+		tags.createdAt !== identity.createdAt
+	)
 		return false;
-	}
 	if (tags.attached || (tags.panePids?.length ?? 0) > 0) return false;
 	if (tags.profile !== GJC_TMUX_PROFILE_VALUE) return false;
 	return await hasTerminalRuntimeMarker(tags);
@@ -205,7 +242,12 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 
 		for (const session of sessions.tagged) {
 			try {
-				records.push(await classifyTaggedSession(session));
+				const record = await classifyTaggedSession(session);
+				records.push(record);
+				if (record.removable) {
+					const identity = collectedIdentity(session);
+					if (identity) collectedIdentities.set(record, identity);
+				}
 			} catch (error) {
 				errors.push({
 					store: STORE,
@@ -227,10 +269,11 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 			return { removed: false, skipped: "not_removable_tmux_session" };
 		}
 		try {
-			if (!(await revalidateRemovable(record, ctx.env))) {
+			const identity = collectedIdentities.get(record);
+			if (!identity || !(await revalidateRemovable(record, identity, ctx.env))) {
 				return { removed: false, skipped: TOCTOU_SKIP };
 			}
-			removeGjcTmuxSession(record.id, ctx.env);
+			removeGjcTmuxSession(record.id, ctx.env, identity);
 			return { removed: true };
 		} catch (error) {
 			return { removed: false, error: error instanceof Error ? error.message : String(error) };

package/src/gjc-runtime/tmux-owner-isolation-cli.ts

@@ -0,0 +1,185 @@
+/** Internal JSON-line facade for the tmux owner-isolation contract. */
+import * as fs from "node:fs/promises";
+import {
+	type BootstrapRequest,
+	bootstrapTmuxOwnerIsolation,
+	classifyCgroup,
+	type ObserveTerminalRequest,
+	type OwnerIsolationProbe,
+	observeOwnerTerminal,
+	type PlanRequest,
+	type PublishGenerationRequest,
+	parseOwnerIsolationRequest,
+	planTmuxOwnerIsolation,
+	publishOwnerGenerationSync,
+	serializeOwnerIsolationResponse,
+	TMUX_OWNER_ISOLATION_MAX_LINE_BYTES,
+	type TmuxServerProof,
+} from "./tmux-owner-isolation";
+
+/** Matches the sole argv shape allowed to enter the owner-isolation JSON-line protocol. */
+export function isTmuxOwnerIsolationCliArgv(argv: readonly string[]): boolean {
+	return argv.length === 1 && argv[0] === "--internal-tmux-owner-isolation";
+}
+
+async function readCgroup(pid = "self"): Promise<string | null> {
+	try {
+		return await fs.readFile(`/proc/${pid}/cgroup`, "utf8");
+	} catch {
+		return null;
+	}
+}
+
+async function readProcessStartTime(pid: number): Promise<string | null> {
+	try {
+		const stat = await fs.readFile(`/proc/${pid}/stat`, "utf8");
+		return (
+			stat
+				.slice(stat.lastIndexOf(")") + 2)
+				.trim()
+				.split(/\s+/)[19] ?? null
+		);
+	} catch {
+		return null;
+	}
+}
+
+function isKnownNoServerDiagnostic(stderr: string): boolean {
+	const diagnostic = stderr.trim().toLowerCase();
+	return (
+		diagnostic.length > 0 &&
+		diagnostic.length <= 512 &&
+		/no server running|failed to connect to server|error connecting to/.test(diagnostic)
+	);
+}
+
+async function tmuxServerProof(socketKey: string, tmuxControlArgv?: string[]): Promise<TmuxServerProof> {
+	void socketKey;
+	if (!tmuxControlArgv?.length) return { state: "unverifiable" };
+	const controlArgv = tmuxControlArgv;
+	const subprocess = Bun.spawnSync([...controlArgv, "list-sessions", "-F", "#{pid}\t#{session_name}"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const stderr = Buffer.from(subprocess.stderr).toString();
+	if (subprocess.exitCode !== 0)
+		return isKnownNoServerDiagnostic(stderr) ? { state: "absent" } : { state: "unverifiable" };
+	const lines = Buffer.from(subprocess.stdout)
+		.toString()
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean);
+	const [pidText] = lines[0]?.split("\t") ?? [];
+	const pid = Number(pidText);
+	const sessionNames = lines.map(line => line.split("\t")[1]).filter((name): name is string => Boolean(name));
+	if (!Number.isSafeInteger(pid) || pid <= 0) return { state: "unverifiable" };
+	if (process.platform !== "linux") {
+		return {
+			state: "safe",
+			pid,
+			startTime: "not_applicable",
+			cgroup: { classification: "not_applicable" },
+			sessionNames,
+		};
+	}
+	const cgroup = classifyCgroup({ platform: process.platform, cgroupText: await readCgroup(String(pid)) });
+	const startTime = await readProcessStartTime(pid);
+	if (!startTime) return { state: "unverifiable", pid, cgroup, sessionNames };
+	return {
+		state:
+			cgroup.classification === "safe"
+				? "safe"
+				: cgroup.classification === "unsafe_service"
+					? "unsafe"
+					: "unverifiable",
+		pid,
+		startTime,
+		cgroup,
+		sessionNames,
+	};
+}
+
+function probe(): OwnerIsolationProbe {
+	return {
+		readCallerCgroup: () => readCgroup(),
+		probeServer: async (socketKey, tmuxArgv) => tmuxServerProof(socketKey, tmuxArgv),
+	};
+}
+
+function cliFailure(diagnostic: string): string {
+	return serializeOwnerIsolationResponse({ schema_version: 1, ok: false, code: "scope_unavailable", diagnostic });
+}
+
+/** Reads exactly one bounded JSON line and writes exactly one JSON response line. */
+export async function runTmuxOwnerIsolationCli(stdin: string): Promise<string> {
+	const line = stdin.endsWith("\n") ? stdin.slice(0, -1) : stdin;
+	if (line.includes("\n")) return cliFailure("invalid_json_line");
+	const request = parseOwnerIsolationRequest(line);
+	if (!request) return cliFailure("invalid_json_line");
+	if (request.op === "plan")
+		return serializeOwnerIsolationResponse(await planTmuxOwnerIsolation(request as PlanRequest, probe()));
+	if (request.op === "bootstrap") {
+		const bootstrap = request as BootstrapRequest;
+		return serializeOwnerIsolationResponse(
+			await bootstrapTmuxOwnerIsolation(bootstrap, {
+				readSelfCgroup: () => readCgroup(),
+				spawn: argv => {
+					const result = Bun.spawnSync(argv, { stdin: "ignore", stdout: "pipe", stderr: "ignore" });
+					return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout).toString() };
+				},
+				probeServer: async (socketKey, tmuxControlArgv) => tmuxServerProof(socketKey, tmuxControlArgv),
+			}),
+		);
+	}
+	if (request.op === "publish_generation") {
+		try {
+			return serializeOwnerIsolationResponse(publishOwnerGenerationSync(request as PublishGenerationRequest));
+		} catch {
+			return cliFailure("generation_publication_failed");
+		}
+	}
+	try {
+		return serializeOwnerIsolationResponse(await observeOwnerTerminal(request as ObserveTerminalRequest));
+	} catch {
+		return cliFailure("terminal_observation_failed");
+	}
+}
+
+const MAX_JSON_LINE_BYTES = TMUX_OWNER_ISOLATION_MAX_LINE_BYTES;
+
+async function readOneBoundedJsonLine(): Promise<string | null> {
+	const reader = Bun.stdin.stream().getReader();
+	const bytes: number[] = [];
+	let complete = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			for (const byte of value) {
+				if (complete || (byte !== 0x0a && bytes.length >= MAX_JSON_LINE_BYTES)) return null;
+				if (byte === 0x0a) {
+					complete = true;
+					continue;
+				}
+				bytes.push(byte);
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new TextDecoder().decode(new Uint8Array(bytes));
+}
+
+export async function runTmuxOwnerIsolationCliFromStdin(): Promise<void> {
+	const stdin = await readOneBoundedJsonLine();
+	const output = stdin === null ? cliFailure("invalid_json_line") : await runTmuxOwnerIsolationCli(stdin);
+	process.stdout.write(`${output}\n`);
+	const request = stdin === null ? null : parseOwnerIsolationRequest(stdin);
+	if (request?.op === "bootstrap") {
+		try {
+			if (JSON.parse(output).ok !== true) process.exitCode = 1;
+		} catch {
+			process.exitCode = 1;
+		}
+	}
+}