@gajae-code/coding-agent 0.5.2 → 0.5.3

package/src/eval/py/executor.ts

@@ -108,7 +108,18 @@ interface PythonSession {
 	queue: Promise<void>;
 }
 
-const sessions = new Map<string, PythonSession>();
+interface InitializingPythonSession {
+	sessionId: string;
+	promise: Promise<PythonSession>;
+}
+
+const sessions = new Map<string, PythonSession | InitializingPythonSession>();
+
+function isInitializingSession(
+	session: PythonSession | InitializingPythonSession,
+): session is InitializingPythonSession {
+	return "promise" in session;
+}
 
 // ---------------------------------------------------------------------------
 // Cancellation plumbing
@@ -288,20 +299,48 @@ function attachOwner(session: PythonSession, sessionId: string, ownerId: string
 async function acquireSession(sessionId: string, cwd: string, options: PythonExecutorOptions): Promise<PythonSession> {
 	const existing = sessions.get(sessionId);
 	if (existing) {
-		attachOwner(existing, sessionId, options.kernelOwnerId);
-		return existing;
+		const session = isInitializingSession(existing)
+			? await waitForPromiseWithCancellation(existing.promise, options)
+			: existing;
+		attachOwner(session, sessionId, options.kernelOwnerId);
+		return session;
 	}
-	const kernel = await startKernel(cwd, options);
-	const session: PythonSession = {
+
+	const initializing: InitializingPythonSession = {
 		sessionId,
-		kernel,
-		ownerIds: new Set(),
-		hasFallbackOwner: false,
-		queue: Promise.resolve(),
+		promise: Promise.resolve().then(async () => {
+			const kernel = await startKernel(cwd, options);
+			const current = sessions.get(sessionId);
+			if (current !== initializing) {
+				await kernel.shutdown().catch(() => undefined);
+				const winner = current
+					? isInitializingSession(current)
+						? await waitForPromiseWithCancellation(current.promise, options)
+						: current
+					: undefined;
+				if (winner) return winner;
+				throw new PythonExecutionCancelledError(false);
+			}
+			const session: PythonSession = {
+				sessionId,
+				kernel,
+				ownerIds: new Set(),
+				hasFallbackOwner: false,
+				queue: Promise.resolve(),
+			};
+			sessions.set(sessionId, session);
+			return session;
+		}),
 	};
-	attachOwner(session, sessionId, options.kernelOwnerId);
-	sessions.set(sessionId, session);
-	return session;
+	sessions.set(sessionId, initializing);
+	try {
+		const session = await waitForPromiseWithCancellation(initializing.promise, options);
+		attachOwner(session, sessionId, options.kernelOwnerId);
+		return session;
+	} catch (err) {
+		if (sessions.get(sessionId) === initializing) sessions.delete(sessionId);
+		throw err;
+	}
 }
 
 async function replaceSessionKernel(
@@ -330,7 +369,8 @@ async function resetSession(sessionId: string): Promise<void> {
 	const existing = sessions.get(sessionId);
 	if (!existing) return;
 	sessions.delete(sessionId);
-	await existing.kernel.shutdown().catch(() => undefined);
+	const session = isInitializingSession(existing) ? await existing.promise.catch(() => undefined) : existing;
+	await session?.kernel.shutdown().catch(() => undefined);
 }
 
 async function runQueued<T>(
@@ -363,11 +403,20 @@ export async function disposeAllKernelSessions(): Promise<void> {
 	for (const [id, session] of all) {
 		if (sessions.get(id) === session) sessions.delete(id);
 	}
-	const results = await Promise.allSettled(all.map(([, session]) => session.kernel.shutdown()));
-	for (let i = 0; i < all.length; i += 1) {
-		const [id, session] = all[i];
+	const resolved = await Promise.all(
+		all.map(
+			async ([id, entry]) =>
+				[id, isInitializingSession(entry) ? await entry.promise.catch(() => undefined) : entry] as const,
+		),
+	);
+	const shutdownTargets = resolved.filter(
+		(entry): entry is readonly [string, PythonSession] => entry[1] !== undefined,
+	);
+	const results = await Promise.allSettled(shutdownTargets.map(([, session]) => session.kernel.shutdown()));
+	for (let i = 0; i < shutdownTargets.length; i += 1) {
+		const [id, session] = shutdownTargets[i];
 		const result = results[i];
-		if (result.status === "fulfilled" && result.value?.confirmed !== false) continue;
+		if (result.status === "fulfilled" && result.value.confirmed) continue;
 		const reason = result.status === "rejected" ? result.reason : "not confirmed";
 		logger.warn("Python kernel shutdown not confirmed", { sessionId: id, reason });
 		if (!sessions.has(id)) sessions.set(id, session);
@@ -377,7 +426,7 @@ export async function disposeAllKernelSessions(): Promise<void> {
 export async function disposeKernelSessionsByOwner(ownerId: string): Promise<void> {
 	const toShutdown: PythonSession[] = [];
 	for (const session of [...sessions.values()]) {
-		if (!session.ownerIds.has(ownerId)) continue;
+		if (isInitializingSession(session) || !session.ownerIds.has(ownerId)) continue;
 		if (session.ownerIds.size === 1) {
 			toShutdown.push(session);
 			continue;
@@ -391,7 +440,7 @@ export async function disposeKernelSessionsByOwner(ownerId: string): Promise<voi
 	for (let i = 0; i < toShutdown.length; i += 1) {
 		const session = toShutdown[i];
 		const result = results[i];
-		if (result.status === "fulfilled" && result.value?.confirmed !== false) {
+		if (result.status === "fulfilled" && result.value.confirmed) {
 			session.ownerIds.delete(ownerId);
 			continue;
 		}

package/src/eval/py/kernel.ts

@@ -3,8 +3,9 @@
  *
  * Speaks NDJSON with `runner.py` over stdin/stdout. One subprocess per kernel
  * instance; sessions reuse a single subprocess across executions. Cancellation
- * is `kill("SIGINT")` which raises a real `KeyboardInterrupt` inside user
- * code. Shutdown writes `{"type":"exit"}` and escalates to SIGTERM/SIGKILL on
+ * sends SIGINT to the runner process group, which raises a real
+ * `KeyboardInterrupt` inside user code and any foreground magic subprocess.
+ * Shutdown writes `{"type":"exit"}` and escalates to SIGTERM/SIGKILL on
  * timeout.
  */
 import * as fs from "node:fs";
@@ -173,6 +174,7 @@ interface PendingExecution {
 	kernelKilled: boolean;
 	settled: boolean;
 	escalationTimer?: NodeJS.Timeout;
+	finalize?: () => void;
 }
 
 export class PythonKernel {
@@ -227,6 +229,9 @@ export class PythonKernel {
 			stdout: "pipe",
 			stderr: "pipe",
 			windowsHide: true,
+			// Run as its own session/process-group leader so SIGINT/SIGTERM can be
+			// delivered to the whole runner tree (incl. foreground magic subprocesses).
+			detached: true,
 		});
 		kernel.#proc = proc;
 		kernel.#stdin = proc.stdin;
@@ -377,10 +382,30 @@ export class PythonKernel {
 
 	async interrupt(): Promise<void> {
 		if (!this.#proc || this.#disposed) return;
+		this.#signalProcessGroup("SIGINT");
+	}
+
+	#signalProcessGroup(signal: NodeJS.Signals): void {
+		const proc = this.#proc;
+		if (!proc) return;
+		try {
+			if (process.platform !== "win32") {
+				process.kill(-proc.pid, signal);
+				return;
+			}
+		} catch (err) {
+			logger.warn("Failed to signal python runner process group", {
+				signal,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
 		try {
-			this.#proc.kill("SIGINT");
+			proc.kill(signal);
 		} catch (err) {
-			logger.warn("Failed to interrupt python runner", { error: err instanceof Error ? err.message : String(err) });
+			logger.warn("Failed to signal python runner", {
+				signal,
+				error: err instanceof Error ? err.message : String(err),
+			});
 		}
 	}
 
@@ -412,24 +437,16 @@ export class PythonKernel {
 
 		const exited = this.#waitForExitWithTimeout(timeoutMs);
 		let result = await exited;
-		if (!result) {
-			try {
-				proc.kill("SIGTERM");
-			} catch {
-				/* ignore */
-			}
+		if (result === null) {
+			this.#signalProcessGroup("SIGTERM");
 			result = await this.#waitForExitWithTimeout(timeoutMs);
 		}
-		if (!result) {
-			try {
-				proc.kill("SIGKILL");
-			} catch {
-				/* ignore */
-			}
+		if (result === null) {
+			this.#signalProcessGroup("SIGKILL");
 			result = await this.#waitForExitWithTimeout(timeoutMs);
 		}
 
-		const confirmed = !!result;
+		const confirmed = result !== null;
 		this.#shutdownConfirmed = confirmed;
 		this.#disposed = true;
 		return { confirmed };
@@ -441,17 +458,21 @@ export class PythonKernel {
 		this.#pending.clear();
 		const kernelKilledDefault = options?.kernelKilled ?? false;
 		for (const entry of pending) {
+			entry.cancelled = true;
+			entry.status = "error";
+			entry.kernelKilled = entry.kernelKilled || kernelKilledDefault;
+			entry.finalize?.();
 			if (entry.settled) continue;
 			entry.settled = true;
 			void entry.options?.onChunk?.(`[kernel] ${reason}\n`);
 			entry.resolve({
-				status: "error",
-				cancelled: true,
+				status: entry.status,
+				cancelled: entry.cancelled,
 				timedOut: entry.timedOut,
 				stdinRequested: entry.stdinRequested,
 				executionCount: entry.executionCount,
 				error: entry.error,
-				kernelKilled: entry.kernelKilled || kernelKilledDefault,
+				kernelKilled: entry.kernelKilled,
 			});
 		}
 	}
@@ -655,11 +676,14 @@ export class PythonKernel {
 	#waitForExitWithTimeout(timeoutMs: number): Promise<number | null> {
 		if (!this.#exitedPromise) return Promise.resolve(0);
 		const exitedPromise = this.#exitedPromise;
-		const timeout = new Promise<null>(resolve => {
+		return new Promise(resolve => {
 			const timer = setTimeout(() => resolve(null), Math.max(0, timeoutMs));
 			timer.unref?.();
+			exitedPromise.then(code => {
+				clearTimeout(timer);
+				resolve(code);
+			});
 		});
-		return Promise.race([exitedPromise.then(code => code as number | null), timeout]);
 	}
 }
 

package/src/eval/py/runner.py

@@ -290,6 +290,44 @@ def _emit_status(op: str, **data: Any) -> None:
     _emit({"type": "display", "id": rid, "bundle": bundle})
 
 
+def _terminate_process_group(proc: subprocess.Popen[Any]) -> None:
+    if proc.poll() is not None:
+        return
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGTERM)
+        else:
+            proc.terminate()
+    except ProcessLookupError:
+        return
+    except Exception:
+        try:
+            proc.terminate()
+        except Exception:
+            pass
+    try:
+        proc.wait(timeout=1)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGKILL)
+        else:
+            proc.kill()
+    except ProcessLookupError:
+        return
+    except Exception:
+        try:
+            proc.kill()
+        except Exception:
+            pass
+    try:
+        proc.wait(timeout=1)
+    except Exception:
+        pass
+
+
 @line_magic("pip")
 def _magic_pip(args: str) -> None:
     argv = shlex.split(args) if args else ["--help"]
@@ -300,18 +338,26 @@ def _magic_pip(args: str) -> None:
         stderr=subprocess.STDOUT,
         text=True,
         bufsize=1,
+        start_new_session=(os.name == "posix"),
     )
     installed_packages: list[str] = []
-    assert proc.stdout is not None
-    for raw_line in proc.stdout:
-        sys.stdout.write(raw_line)
-        m = re.search(r"Successfully installed\s+(.+)$", raw_line)
-        if m:
-            for token in m.group(1).split():
-                # Token is name-version; drop the version suffix.
-                pkg = token.rsplit("-", 1)[0]
-                installed_packages.append(pkg.replace("_", "-"))
-    proc.wait()
+    try:
+        assert proc.stdout is not None
+        try:
+            for raw_line in proc.stdout:
+                sys.stdout.write(raw_line)
+                m = re.search(r"Successfully installed\s+(.+)$", raw_line)
+                if m:
+                    for token in m.group(1).split():
+                        # Token is name-version; drop the version suffix.
+                        pkg = token.rsplit("-", 1)[0]
+                        installed_packages.append(pkg.replace("_", "-"))
+        finally:
+            proc.stdout.close()
+        proc.wait()
+    except KeyboardInterrupt:
+        _terminate_process_group(proc)
+        raise
     if installed_packages:
         import importlib
 
@@ -500,11 +546,19 @@ def _run_shell_body(body: str, *, shell_arg: str) -> int:
         stderr=subprocess.STDOUT,
         text=True,
         bufsize=1,
+        start_new_session=(os.name == "posix"),
     )
-    assert proc.stdout is not None
-    for raw_line in proc.stdout:
-        sys.stdout.write(raw_line)
-    proc.wait()
+    try:
+        assert proc.stdout is not None
+        try:
+            for raw_line in proc.stdout:
+                sys.stdout.write(raw_line)
+        finally:
+            proc.stdout.close()
+        proc.wait()
+    except KeyboardInterrupt:
+        _terminate_process_group(proc)
+        raise
     return proc.returncode
 
 

package/src/exec/bash-executor.ts

@@ -32,6 +32,8 @@ export interface BashExecutorOptions {
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
+	/** Execute without retaining a native Shell in the persistent session registry. */
+	oneShot?: boolean;
 	/**
 	 * Invoked when the native minimizer rewrote the command's output, giving
 	 * the caller a chance to persist the lossless original capture (typically
@@ -59,6 +61,8 @@ export interface BashResult {
 
 const shellSessions = new Map<string, Shell>();
 const brokenShellSessions = new Set<string>();
+const retiringShellSessions = new Set<Shell>();
+const CANCEL_CLEANUP_WAIT_MS = 250;
 
 /** Number of persistent shell sessions currently retained (owner gauge). */
 export function getShellSessionCount(): number {
@@ -76,10 +80,14 @@ export async function disposeAllShellSessions(): Promise<void> {
 	// Snapshot and drop strong references up front so concurrent callers cannot
 	// reuse a session that is being torn down, then await every native abort so
 	// shutdown/signal cleanup does not return before resources are released.
-	const sessions = [...shellSessions.values()];
+	// Include retiring shells whose JS call returned after bounded abort cleanup
+	// while the native run is still unwinding; they are no longer reusable but
+	// remain owned until their run promise settles.
+	const sessions = new Set([...shellSessions.values(), ...retiringShellSessions]);
 	shellSessions.clear();
+	retiringShellSessions.clear();
 	brokenShellSessions.clear();
-	await Promise.allSettled(sessions.map(session => session.abort()));
+	await Promise.allSettled([...sessions].map(session => session.abort()));
 }
 
 postmortem.register("bash-executor:shell-sessions", () => disposeAllShellSessions());
@@ -151,14 +159,12 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	}
 
+	const usePersistentShell = options?.oneShot !== true;
 	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
-	const persistentSessionBroken = brokenShellSessions.has(sessionKey);
-	if (persistentSessionBroken) {
-		shellSessions.delete(sessionKey);
-	}
+	const persistentSessionBroken = usePersistentShell && brokenShellSessions.has(sessionKey);
 
-	let shellSession = persistentSessionBroken ? undefined : shellSessions.get(sessionKey);
-	if (!shellSession && !persistentSessionBroken) {
+	let shellSession = persistentSessionBroken || !usePersistentShell ? undefined : shellSessions.get(sessionKey);
+	if (!shellSession && !persistentSessionBroken && usePersistentShell) {
 		shellSession = new Shell({
 			sessionEnv: shellEnv,
 			snapshotPath: snapshotPath ?? undefined,
@@ -172,16 +178,29 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (!runAbortController.signal.aborted) {
 			runAbortController.abort();
 		}
-		if (shellSession) {
-			// Native abort is async; fire-and-forget because the caller races the command separately.
-			void shellSession.abort();
+		if (shellSession && !abortPromise) {
+			abortPromise = shellSession.abort();
 		}
 	};
 	const abortDeferred = Promise.withResolvers<"abort">();
+	let abortPromise: Promise<unknown> | undefined;
 	const abortHandler = () => {
 		abortCurrentExecution();
 		abortDeferred.resolve("abort");
 	};
+	const awaitAbortCleanup = async (runPromise: Promise<unknown>): Promise<boolean> => {
+		const settled = await Promise.race([
+			runPromise.then(
+				() => true,
+				() => true,
+			),
+			Bun.sleep(CANCEL_CLEANUP_WAIT_MS).then(() => false),
+		]);
+		if (abortPromise) {
+			await Promise.race([abortPromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
+		}
+		return settled;
+	};
 	if (userSignal) {
 		userSignal.addEventListener("abort", abortHandler, { once: true });
 	}
@@ -198,6 +217,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	}
 
 	let resetSession = false;
+	let runSettled = false;
 
 	try {
 		const runPromise = shellSession
@@ -243,8 +263,24 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			acceptingChunks = false;
 			if (shellSession) {
 				resetSession = true;
+				retiringShellSessions.add(shellSession);
 				brokenShellSessions.add(sessionKey);
-				void runPromise.finally(() => brokenShellSessions.delete(sessionKey)).catch(() => undefined);
+				shellSessions.delete(sessionKey);
+				runSettled = await awaitAbortCleanup(runPromise);
+				if (runSettled) {
+					brokenShellSessions.delete(sessionKey);
+					retiringShellSessions.delete(shellSession);
+				} else {
+					void runPromise
+						.finally(() => {
+							brokenShellSessions.delete(sessionKey);
+							retiringShellSessions.delete(shellSession);
+							if (shellSessions.get(sessionKey) === shellSession) {
+								shellSessions.delete(sessionKey);
+							}
+						})
+						.catch(() => undefined);
+				}
 			} else {
 				void runPromise.catch(() => undefined);
 			}
@@ -337,7 +373,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (userSignal) {
 			userSignal.removeEventListener("abort", abortHandler);
 		}
-		if (resetSession) {
+		if (resetSession && runSettled && shellSessions.get(sessionKey) === shellSession) {
 			shellSessions.delete(sessionKey);
 		}
 	}

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

@@ -8,7 +8,7 @@ import * as fs from "node:fs";
 
 import { worktree } from "../utils/git";
 import type { GcCollectResult, GcContext, GcPruneOutcome, GcRecord, GcStoreAdapter } from "./gc-runtime";
-import { GJC_TMUX_PROFILE_VALUE } from "./tmux-common";
+import { GJC_TMUX_PROFILE_VALUE, GJC_TMUX_SESSION_PREFIX } from "./tmux-common";
 import {
 	type GjcTmuxSessionStatus,
 	type GjcTmuxSessionsForGc,
@@ -19,6 +19,7 @@ import {
 
 const STORE = "tmux_sessions" as const;
 const TOCTOU_SKIP = "tmux_revalidation_failed_or_became_live";
+const ORPHAN_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 function pathExists(path: string): boolean {
 	try {
@@ -65,39 +66,62 @@ async function hasLiveWorktreeForBranch(project: string, branch: string): Promis
 	return entries.some(entry => branchMatches(entry.branch, branch));
 }
 
+function isSessionLive(session: Pick<GjcTmuxSessionStatus, "attached" | "panePids">): boolean {
+	return session.attached || session.panePids.length > 0;
+}
+
+function liveRecord(session: GjcTmuxSessionStatus, reason: string): GcRecord {
+	return {
+		store: STORE,
+		id: session.name,
+		path: session.project,
+		root: session.project,
+		pid_status: "alive",
+		status: "live",
+		stale: false,
+		removable: false,
+		action: "none",
+		reason,
+		detail: detail(session.project, session.branch),
+	};
+}
+
+function staleRecord(session: GjcTmuxSessionStatus, reason: string): GcRecord {
+	return {
+		store: STORE,
+		id: session.name,
+		path: session.project,
+		root: session.project,
+		pid_status: "none",
+		status: "stale",
+		stale: true,
+		removable: true,
+		action: "none",
+		reason,
+		detail: `${detail(session.project, session.branch) ?? ""} createdAt=${session.createdAt}`.trim(),
+	};
+}
+
+function isOldEnoughForOrphanGc(session: GjcTmuxSessionStatus): boolean {
+	const createdAt = Date.parse(session.createdAt);
+	return Number.isFinite(createdAt) && Date.now() - createdAt >= ORPHAN_MAX_AGE_MS;
+}
+
+function isGjcOwnedOrphan(session: GjcTmuxSessionStatus): boolean {
+	return session.name.startsWith(GJC_TMUX_SESSION_PREFIX) || session.name === "gajae_code";
+}
+
 async function classifyTaggedSession(session: GjcTmuxSessionStatus): Promise<GcRecord> {
 	const { name, project, branch } = session;
-	if (!project || !branch) return unclassifiedRecord(name, "missing_project_or_branch_tag", project, branch);
-	if (!pathExists(project)) {
-		return {
-			store: STORE,
-			id: name,
-			path: project,
-			root: project,
-			pid_status: "none",
-			status: "stale",
-			stale: true,
-			removable: true,
-			action: "none",
-			reason: "project_missing",
-			detail: detail(project, branch),
-		};
-	}
-	if (!(await hasLiveWorktreeForBranch(project, branch))) {
-		return {
-			store: STORE,
-			id: name,
-			path: project,
-			root: project,
-			pid_status: "none",
-			status: "stale",
-			stale: true,
-			removable: true,
-			action: "none",
-			reason: "branch_no_worktree",
-			detail: detail(project, branch),
-		};
+	if (isSessionLive(session)) return liveRecord(session, "tmux_session_attached_or_has_live_panes");
+	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);
 	}
+	if (!pathExists(project)) return staleRecord(session, "project_missing");
+	if (!(await hasLiveWorktreeForBranch(project, branch))) return staleRecord(session, "branch_no_worktree");
 	return {
 		store: STORE,
 		id: name,
@@ -113,9 +137,34 @@ async function classifyTaggedSession(session: GjcTmuxSessionStatus): Promise<GcR
 	};
 }
 
-async function revalidateRemovable(name: string, env: NodeJS.ProcessEnv): Promise<boolean> {
-	const tags = readTmuxSessionTagsForGc(name, env);
-	if (tags.profile !== GJC_TMUX_PROFILE_VALUE || !tags.project || !tags.branch) return false;
+function classifyUntaggedSession(session: GjcTmuxSessionStatus): GcRecord {
+	return unclassifiedRecord(session.name, "untagged_tmux_session");
+}
+
+async function revalidateRemovable(record: GcRecord, env: NodeJS.ProcessEnv): Promise<boolean> {
+	const tags = readTmuxSessionTagsForGc(record.id, env);
+	if (
+		tags.createdAt &&
+		record.detail?.includes("createdAt=") &&
+		!record.detail.includes(`createdAt=${tags.createdAt}`)
+	) {
+		return false;
+	}
+	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));
 }
@@ -154,8 +203,8 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 			}
 		}
 
-		for (const name of sessions.untagged) {
-			records.push(unclassifiedRecord(name, "untagged_tmux_session"));
+		for (const session of sessions.untagged) {
+			records.push(classifyUntaggedSession(session));
 		}
 
 		return { records, errors };
@@ -165,7 +214,7 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 			return { removed: false, skipped: "not_removable_tmux_session" };
 		}
 		try {
-			if (!(await revalidateRemovable(record.id, ctx.env))) {
+			if (!(await revalidateRemovable(record, ctx.env))) {
 				return { removed: false, skipped: TOCTOU_SKIP };
 			}
 			removeGjcTmuxSession(record.id, ctx.env);