@gajae-code/coding-agent 0.5.4 → 0.6.1

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

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { safeStderrWrite } from "@gajae-code/utils";
 import type { Args } from "../cli/args";
+import { GJC_COORDINATOR_SESSION_ID_ENV, GJC_COORDINATOR_SESSION_STATE_FILE_ENV } from "./session-state-sidecar";
 import {
 	buildGjcTmuxProfileCommands,
 	buildGjcTmuxSessionName,
@@ -26,6 +27,7 @@ export {
 
 export const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
 export const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
+export const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
 
 type LaunchPolicy = "direct" | "tmux";
 
@@ -77,6 +79,8 @@ export interface TmuxLaunchPlan {
 	branch?: string | null;
 	attachSessionName?: string;
 	project?: string | null;
+	sessionId?: string | null;
+	sessionStateFile?: string | null;
 }
 
 export interface GjcTmuxProfileResult {
@@ -94,12 +98,15 @@ export interface GjcTmuxProfileContext {
 	branch?: string | null;
 	branchSlug?: string | null;
 	project?: string | null;
+	sessionId?: string | null;
+	sessionStateFile?: string | null;
 }
 
 interface CommandResolutionContext {
 	cwd: string;
 	argv: string[];
 	execPath: string;
+	extraEnv?: Record<string, string>;
 }
 
 function parseLaunchPolicy(env: NodeJS.ProcessEnv): LaunchPolicy {
@@ -137,6 +144,11 @@ function shellQuote(value: string): string {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
+function buildEnvAssignments(values: Record<string, string> | undefined): string {
+	const entries = Object.entries(values ?? {});
+	return entries.length === 0 ? "" : ` ${entries.map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ")}`;
+}
+
 export function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProfileResult {
 	const env = context.env ?? process.env;
 	const branchSlug = context.branch ? buildGjcTmuxSessionSlug(context.branch) : (context.branchSlug ?? null);
@@ -144,6 +156,8 @@ export function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProf
 		branch: context.branch ?? null,
 		branchSlug,
 		project: context.project ?? null,
+		sessionId: context.sessionId ?? env[GJC_COORDINATOR_SESSION_ID_ENV] ?? null,
+		sessionStateFile: context.sessionStateFile ?? env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV] ?? null,
 	});
 	if (commands.length === 0) return { skipped: true, commands: [], failures: [] };
 	const spawnSync = context.spawnSync ?? defaultSpawnSync;
@@ -173,7 +187,97 @@ function resolveCurrentGjcCommand(context: CommandResolutionContext): string[] {
 function buildInnerCommand(context: CommandResolutionContext, rawArgs: string[]): string {
 	const command = resolveCurrentGjcCommand(context);
 	const quoted = [...command, ...rawArgs].map(shellQuote).join(" ");
-	return `exec env ${GJC_TMUX_LAUNCHED_ENV}=1 ${quoted}`;
+	return `exec env ${GJC_TMUX_LAUNCHED_ENV}=1${buildEnvAssignments(context.extraEnv)} ${quoted}`;
+}
+
+function visibleWidth(value: string): number {
+	return Bun.stringWidth(value);
+}
+
+function truncateVisible(value: string, maxWidth: number): string {
+	if (maxWidth <= 0) return "";
+	if (visibleWidth(value) <= maxWidth) return value;
+	if (maxWidth === 1) return "…";
+
+	let result = "";
+	for (const char of value) {
+		if (visibleWidth(`${result}${char}…`) > maxWidth) break;
+		result += char;
+	}
+
+	return `${result}…`;
+}
+
+function truncateVisibleTail(value: string, maxWidth: number): string {
+	if (maxWidth <= 0) return "";
+	if (visibleWidth(value) <= maxWidth) return value;
+	if (maxWidth === 1) return "…";
+
+	let result = "";
+	for (const char of Array.from(value).reverse()) {
+		if (visibleWidth(`…${char}${result}`) > maxWidth) break;
+		result = `${char}${result}`;
+	}
+
+	return `…${result}`;
+}
+
+export function buildGjcTmuxWindowTitle(cwd: string, branch: string | null | undefined): string {
+	const project = path.basename(path.resolve(cwd)) || "gjc";
+	const trimmedBranch = branch?.trim();
+	if (!trimmedBranch) return truncateVisible(project, GJC_TMUX_WINDOW_LABEL_MAX_WIDTH);
+
+	const separatorWidth = visibleWidth(":");
+	const projectWidth = visibleWidth(project);
+	const fullTitle = `${project}:${trimmedBranch}`;
+	if (visibleWidth(fullTitle) <= GJC_TMUX_WINDOW_LABEL_MAX_WIDTH) return fullTitle;
+
+	const remainingBranchWidth = GJC_TMUX_WINDOW_LABEL_MAX_WIDTH - projectWidth - separatorWidth;
+	if (remainingBranchWidth <= 0) return truncateVisible(project, GJC_TMUX_WINDOW_LABEL_MAX_WIDTH);
+
+	return `${project}:${truncateVisibleTail(trimmedBranch, remainingBranchWidth)}`;
+}
+
+function buildTmuxRenameWindowArgs(title: string, target?: string): string[] {
+	return target ? ["rename-window", "-t", target, "--", title] : ["rename-window", "--", title];
+}
+
+function renameTmuxWindow(
+	tmuxCommand: string,
+	title: string,
+	spawnSync: TmuxSpawnSync,
+	options: TmuxSpawnOptions,
+	target?: string,
+): void {
+	spawnSync(tmuxCommand, buildTmuxRenameWindowArgs(title, target), options);
+}
+
+function renameExistingTmuxWindowIfNeeded(context: TmuxLaunchContext): void {
+	const env = context.env ?? process.env;
+	if (!env.TMUX || env[GJC_TMUX_LAUNCHED_ENV] === "1") return;
+	if (parseLaunchPolicy(env) === "direct") return;
+
+	const platform = context.platform ?? process.platform;
+	if (platform === "win32") return;
+
+	const tty = context.tty ?? { stdin: Boolean(process.stdin.isTTY), stdout: Boolean(process.stdout.isTTY) };
+	if (!isInteractiveRootLaunch(context.parsed, tty)) return;
+
+	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
+	if (!tmuxAvailable) return;
+
+	const cwd = context.cwd ?? process.cwd();
+	const branch = context.worktreeBranch ?? context.currentBranch ?? readCurrentBranch(cwd);
+	const title = buildGjcTmuxWindowTitle(context.project ?? cwd, branch);
+	const spawnSync = context.spawnSync ?? defaultSpawnSync;
+	renameTmuxWindow(tmuxCommand, title, spawnSync, {
+		cwd,
+		env,
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	});
 }
 
 function readCurrentBranch(cwd: string): string | null {
@@ -210,6 +314,10 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 	const project = context.project ?? cwd;
 	const sessionName = buildGjcTmuxSessionName(env, { branch });
 	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const sessionId = env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || sessionName;
+	const sessionStateFile =
+		env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim() ||
+		path.join(cwd, ".gjc", "runtime", "tmux-sessions", `${buildGjcTmuxSessionSlug(sessionName)}.json`);
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return undefined;
 	const existingBranchSessionName =
@@ -223,6 +331,10 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 			cwd,
 			argv: context.argv ?? process.argv,
 			execPath: context.execPath ?? process.execPath,
+			extraEnv: {
+				[GJC_COORDINATOR_SESSION_ID_ENV]: sessionId,
+				[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
+			},
 		},
 		context.rawArgs,
 	);
@@ -234,6 +346,8 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		newSessionArgs: ["new-session", "-d", "-s", sessionName, "-c", cwd, innerCommand],
 		branch,
 		project,
+		sessionId,
+		sessionStateFile,
 		attachSessionName: existingBranchSessionName,
 	};
 }
@@ -251,6 +365,8 @@ function defaultSpawnSync(command: string, args: string[], options: TmuxSpawnOpt
 }
 
 export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
+	renameExistingTmuxWindowIfNeeded(context);
+
 	const plan = buildDefaultTmuxLaunchPlan(context);
 	if (!plan) return false;
 	const env = context.env ?? process.env;
@@ -262,12 +378,22 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 		stdout: "inherit",
 		stderr: "inherit",
 	};
+
 	if (plan.attachSessionName) {
 		const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.attachSessionName}`], options);
 		return attached.exitCode === 0;
 	}
+
 	const created = spawnSync(plan.tmuxCommand, plan.newSessionArgs, options);
 	if (created.exitCode === 0) {
+		renameTmuxWindow(
+			plan.tmuxCommand,
+			buildGjcTmuxWindowTitle(plan.project ?? plan.cwd, plan.branch),
+			spawnSync,
+			options,
+			`=${plan.sessionName}`,
+		);
+
 		const profile = applyGjcTmuxProfile({
 			tmuxCommand: plan.tmuxCommand,
 			target: plan.sessionName,
@@ -276,6 +402,8 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 			spawnSync,
 			branch: plan.branch,
 			project: plan.project,
+			sessionId: plan.sessionId ?? null,
+			sessionStateFile: plan.sessionStateFile ?? null,
 		});
 		if (profile.failures.length > 0) {
 			cleanupCreatedTmuxSession(plan, spawnSync, options);

package/src/gjc-runtime/session-state-sidecar.ts

@@ -6,7 +6,7 @@ import { logger } from "@gajae-code/utils";
 export const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
 export const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
 
-type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
+export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
 
 interface RuntimeStateEvent {
 	type: string;
@@ -19,6 +19,66 @@ interface RuntimeStateContext {
 	sessionFile?: string | null;
 }
 
+interface RuntimeStateSidecarPayload {
+	schema_version?: unknown;
+	session_id?: unknown;
+	state?: unknown;
+	ready_for_input?: unknown;
+	cwd?: unknown;
+	session_file?: unknown;
+}
+
+export type TerminalRuntimeStateStatus =
+	| { terminal: true; state: "completed" | "errored" }
+	| {
+			terminal: false;
+			reason:
+				| "missing_state_file"
+				| "invalid_json"
+				| "session_id_mismatch"
+				| "cwd_mismatch"
+				| "session_file_mismatch"
+				| "non_terminal_state";
+	  };
+
+function sameResolvedPath(left: string, right: string): boolean {
+	return path.resolve(left) === path.resolve(right);
+}
+
+export async function readTerminalRuntimeStateMarker(input: {
+	stateFile?: string | null;
+	sessionId?: string | null;
+	cwd?: string | null;
+	sessionFile?: string | null;
+}): Promise<TerminalRuntimeStateStatus> {
+	const stateFile = input.stateFile?.trim();
+	const sessionId = input.sessionId?.trim();
+	if (!stateFile || !sessionId) return { terminal: false, reason: "missing_state_file" };
+	let payload: RuntimeStateSidecarPayload;
+	try {
+		payload = JSON.parse(await Bun.file(stateFile).text()) as RuntimeStateSidecarPayload;
+	} catch (error) {
+		const code = (error as { code?: unknown }).code;
+		return {
+			terminal: false,
+			reason: code === "ENOENT" || code === "ENOTDIR" ? "missing_state_file" : "invalid_json",
+		};
+	}
+	if (payload.session_id !== sessionId) return { terminal: false, reason: "session_id_mismatch" };
+	if (input.cwd && typeof payload.cwd === "string" && !sameResolvedPath(payload.cwd, input.cwd)) {
+		return { terminal: false, reason: "cwd_mismatch" };
+	}
+	if (
+		input.sessionFile &&
+		typeof payload.session_file === "string" &&
+		!sameResolvedPath(payload.session_file, input.sessionFile)
+	) {
+		return { terminal: false, reason: "session_file_mismatch" };
+	}
+	if (payload.state === "completed" || payload.state === "errored") return { terminal: true, state: payload.state };
+	return { terminal: false, reason: "non_terminal_state" };
+}
+
 function lastAssistant(messages: unknown[] | undefined): AssistantMessage | undefined {
 	if (!messages) return undefined;
 	for (let index = messages.length - 1; index >= 0; index--) {

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

@@ -8,6 +8,8 @@ export const GJC_TMUX_PROFILE_VALUE = "1";
 export const GJC_TMUX_BRANCH_OPTION = "@gjc-branch";
 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 interface GjcTmuxProfileCommand {
 	description: string;
@@ -93,7 +95,13 @@ export function buildGjcTmuxSessionName(
 
 export function buildGjcTmuxRequiredProfileCommands(
 	target: string,
-	metadata: { branch?: string | null; branchSlug?: string | null; project?: string | null } = {},
+	metadata: {
+		branch?: string | null;
+		branchSlug?: string | null;
+		project?: string | null;
+		sessionId?: string | null;
+		sessionStateFile?: string | null;
+	} = {},
 ): GjcTmuxProfileCommand[] {
 	const commands: GjcTmuxProfileCommand[] = [
 		{
@@ -116,13 +124,29 @@ export function buildGjcTmuxRequiredProfileCommands(
 			description: "record GJC project identity",
 			args: ["set-option", "-t", target, GJC_TMUX_PROJECT_OPTION, metadata.project],
 		});
+	if (metadata.sessionId)
+		commands.push({
+			description: "record GJC session identity",
+			args: ["set-option", "-t", target, GJC_TMUX_SESSION_ID_OPTION, metadata.sessionId],
+		});
+	if (metadata.sessionStateFile)
+		commands.push({
+			description: "record GJC session state marker",
+			args: ["set-option", "-t", target, GJC_TMUX_SESSION_STATE_FILE_OPTION, metadata.sessionStateFile],
+		});
 	return commands;
 }
 
 export function buildGjcTmuxProfileCommands(
 	target: string,
 	env: NodeJS.ProcessEnv = process.env,
-	metadata: { branch?: string | null; branchSlug?: string | null; project?: string | null } = {},
+	metadata: {
+		branch?: string | null;
+		branchSlug?: string | null;
+		project?: string | null;
+		sessionId?: string | null;
+		sessionStateFile?: string | null;
+	} = {},
 ): GjcTmuxProfileCommand[] {
 	const commands = buildGjcTmuxRequiredProfileCommands(target, metadata);
 	if (envDisabled(env[GJC_TMUX_PROFILE_ENV])) return commands;

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

@@ -1,13 +1,14 @@
 /**
- * GC adapter for gjc-tagged tmux sessions. Stale iff `@gjc-project` path is gone
- * OR `@gjc-branch` has no live git worktree. Removal is a spec-authorized
- * destructive `kill-session`, gated by exact-target re-read + revalidation.
+ * GC adapter for gjc-tagged tmux sessions. Destructive cleanup is authorized
+ * only for detached pane-less sessions whose exact runtime marker revalidates a
+ * terminal state. Project/branch/orphan heuristics are discovery signals only.
  */
 
 import * as fs from "node:fs";
 
-import { worktree } from "../utils/git";
+import { GitCommandError, worktree } from "../utils/git";
 import type { GcCollectResult, GcContext, GcPruneOutcome, GcRecord, GcStoreAdapter } from "./gc-runtime";
+import { readTerminalRuntimeStateMarker } from "./session-state-sidecar";
 import { GJC_TMUX_PROFILE_VALUE, GJC_TMUX_SESSION_PREFIX } from "./tmux-common";
 import {
 	type GjcTmuxSessionStatus,
@@ -60,10 +61,18 @@ function branchMatches(candidate: string | undefined, branch: string): boolean {
 	]);
 	return branchNames.has(candidate);
 }
+function isNotGitRepositoryError(error: unknown): boolean {
+	return error instanceof GitCommandError && /not a git repository/i.test(error.message);
+}
 
 async function hasLiveWorktreeForBranch(project: string, branch: string): Promise<boolean> {
-	const entries = await worktree.list(project);
-	return entries.some(entry => branchMatches(entry.branch, branch));
+	try {
+		const entries = await worktree.list(project);
+		return entries.some(entry => branchMatches(entry.branch, branch));
+	} catch (error) {
+		if (isNotGitRepositoryError(error)) return false;
+		throw error;
+	}
 }
 
 function isSessionLive(session: Pick<GjcTmuxSessionStatus, "attached" | "panePids">): boolean {
@@ -102,6 +111,19 @@ function staleRecord(session: GjcTmuxSessionStatus, reason: string): GcRecord {
 	};
 }
 
+async function hasTerminalRuntimeMarker(input: {
+	sessionId?: string | null;
+	sessionStateFile?: string | null;
+	project?: string | null;
+}): Promise<boolean> {
+	const marker = await readTerminalRuntimeStateMarker({
+		stateFile: input.sessionStateFile,
+		sessionId: input.sessionId,
+		cwd: input.project,
+	});
+	return marker.terminal;
+}
+
 function isOldEnoughForOrphanGc(session: GjcTmuxSessionStatus): boolean {
 	const createdAt = Date.parse(session.createdAt);
 	return Number.isFinite(createdAt) && Date.now() - createdAt >= ORPHAN_MAX_AGE_MS;
@@ -114,14 +136,19 @@ function isGjcOwnedOrphan(session: GjcTmuxSessionStatus): boolean {
 async function classifyTaggedSession(session: GjcTmuxSessionStatus): Promise<GcRecord> {
 	const { name, project, branch } = session;
 	if (isSessionLive(session)) return liveRecord(session, "tmux_session_attached_or_has_live_panes");
+	if (await hasTerminalRuntimeMarker(session))
+		return staleRecord(session, "terminal_runtime_marker_detached_idle_session");
 	if (!project || !branch) {
-		if (isGjcOwnedOrphan(session) && isOldEnoughForOrphanGc(session)) {
-			return staleRecord(session, "metadata_less_gjc_owned_idle_orphan");
-		}
-		return unclassifiedRecord(name, "missing_project_or_branch_tag", project, branch);
+		const reason =
+			isGjcOwnedOrphan(session) && isOldEnoughForOrphanGc(session)
+				? "metadata_less_gjc_owned_idle_orphan_missing_terminal_marker"
+				: "missing_project_or_branch_tag";
+		return unclassifiedRecord(name, reason, project, branch);
 	}
-	if (!pathExists(project)) return staleRecord(session, "project_missing");
-	if (!(await hasLiveWorktreeForBranch(project, branch))) return staleRecord(session, "branch_no_worktree");
+	if (!pathExists(project))
+		return unclassifiedRecord(name, "project_missing_without_terminal_marker", project, branch);
+	if (!(await hasLiveWorktreeForBranch(project, branch)))
+		return unclassifiedRecord(name, "branch_no_worktree_without_terminal_marker", project, branch);
 	return {
 		store: STORE,
 		id: name,
@@ -152,21 +179,7 @@ async function revalidateRemovable(record: GcRecord, env: NodeJS.ProcessEnv): Pr
 	}
 	if (tags.attached || (tags.panePids?.length ?? 0) > 0) return false;
 	if (tags.profile !== GJC_TMUX_PROFILE_VALUE) return false;
-	if (!tags.project || !tags.branch)
-		return (
-			record.reason === "metadata_less_gjc_owned_idle_orphan" &&
-			isGjcOwnedOrphan({
-				name: record.id,
-				attached: false,
-				windows: 0,
-				panes: 0,
-				panePids: [],
-				bindings: "",
-				createdAt: tags.createdAt ?? "",
-			})
-		);
-	if (!pathExists(tags.project)) return true;
-	return !(await hasLiveWorktreeForBranch(tags.project, tags.branch));
+	return await hasTerminalRuntimeMarker(tags);
 }
 
 export const tmuxSessionsGcAdapter: GcStoreAdapter = {

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

@@ -8,6 +8,8 @@ import {
 	GJC_TMUX_PROFILE_OPTION,
 	GJC_TMUX_PROFILE_VALUE,
 	GJC_TMUX_PROJECT_OPTION,
+	GJC_TMUX_SESSION_ID_OPTION,
+	GJC_TMUX_SESSION_STATE_FILE_OPTION,
 	normalizeTmuxCreatedAt,
 	resolveGjcTmuxCommand,
 } from "./tmux-common";
@@ -22,6 +24,8 @@ export interface GjcTmuxSessionStatus {
 	branch?: string;
 	branchSlug?: string;
 	project?: string;
+	sessionId?: string;
+	sessionStateFile?: string;
 	panePids: number[];
 	profile?: string;
 }
@@ -31,6 +35,8 @@ export interface GjcTmuxSessionTagsForGc {
 	project?: string;
 	branch?: string;
 	branchSlug?: string;
+	sessionId?: string;
+	sessionStateFile?: string;
 	createdAt?: string;
 	attached?: boolean;
 	panePids?: number[];
@@ -78,6 +84,8 @@ function parseSessionLine(line: string): GjcTmuxSessionStatus | null {
 		branch = "",
 		branchSlug = "",
 		project = "",
+		sessionId = "",
+		sessionStateFile = "",
 	] = line.split("\t");
 	if (!name) return null;
 	return {
@@ -95,6 +103,8 @@ function parseSessionLine(line: string): GjcTmuxSessionStatus | null {
 		branchSlug: branchSlug || undefined,
 		project: project || undefined,
 		profile: profile || undefined,
+		sessionId: sessionId || undefined,
+		sessionStateFile: sessionStateFile || undefined,
 	};
 }
 
@@ -115,7 +125,7 @@ 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#{${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}}`,
+		`#{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}}`,
 		env,
 	);
 }
@@ -228,6 +238,8 @@ export function readTmuxSessionTagsForGc(
 		project: readExactOptionForGc(sessionName, GJC_TMUX_PROJECT_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),
 		createdAt: session?.createdAt,
 		attached: session?.attached,
 		panePids: session?.panePids,