@gajae-code/coding-agent 0.5.2 → 0.5.4

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);

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

@@ -22,17 +22,23 @@ export interface GjcTmuxSessionStatus {
 	branch?: string;
 	branchSlug?: string;
 	project?: string;
+	panePids: number[];
+	profile?: string;
 }
 
 export interface GjcTmuxSessionTagsForGc {
 	profile?: string;
 	project?: string;
 	branch?: string;
+	branchSlug?: string;
+	createdAt?: string;
+	attached?: boolean;
+	panePids?: number[];
 }
 
 export interface GjcTmuxSessionsForGc {
 	tagged: GjcTmuxSessionStatus[];
-	untagged: string[];
+	untagged: GjcTmuxSessionStatus[];
 }
 
 function runTmux(args: string[], env: NodeJS.ProcessEnv = process.env): string {
@@ -68,21 +74,27 @@ function parseSessionLine(line: string): GjcTmuxSessionStatus | null {
 		profile = "",
 		bindings = "",
 		panes = "0",
+		panePids = "",
 		branch = "",
 		branchSlug = "",
 		project = "",
 	] = line.split("\t");
-	if (!name || profile !== GJC_TMUX_PROFILE_VALUE) return null;
+	if (!name) return null;
 	return {
 		name,
 		attached: parseBooleanFlag(attached),
 		windows: parseNumber(windows),
 		panes: parseNumber(panes),
+		panePids: panePids
+			.split(",")
+			.map(pid => parseNumber(pid))
+			.filter(pid => pid > 0),
 		bindings,
 		createdAt: normalizeTmuxCreatedAt(created),
 		branch: branch || undefined,
 		branchSlug: branchSlug || undefined,
 		project: project || undefined,
+		profile: profile || undefined,
 	};
 }
 
@@ -103,7 +115,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#{${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}}`,
 		env,
 	);
 }
@@ -115,17 +127,35 @@ function listRawTmuxSessionNames(env: NodeJS.ProcessEnv = process.env): string[]
 export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus[] {
 	return listSessionLines(env)
 		.map(parseSessionLine)
-		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.filter((session): session is GjcTmuxSessionStatus => session?.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 /** @internal */
 export function listTmuxSessionsForGc(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionsForGc {
-	const tagged = listGjcTmuxSessions(env);
+	const sessions = listSessionLines(env)
+		.map(parseSessionLine)
+		.filter((session): session is GjcTmuxSessionStatus => session != null);
+	const tagged = sessions
+		.filter(session => session.profile === GJC_TMUX_PROFILE_VALUE)
+		.sort((a, b) => a.name.localeCompare(b.name));
 	const taggedNames = new Set(tagged.map(session => session.name));
+	const byName = new Map(sessions.map(session => [session.name, session]));
 	const untagged = listRawTmuxSessionNames(env)
 		.filter(name => !taggedNames.has(name))
-		.sort((a, b) => a.localeCompare(b));
+		.map(
+			name =>
+				byName.get(name) ?? {
+					name,
+					attached: false,
+					windows: 0,
+					panes: 0,
+					panePids: [],
+					bindings: "",
+					createdAt: "",
+				},
+		)
+		.sort((a, b) => a.name.localeCompare(b.name));
 	return { tagged, untagged };
 }
 
@@ -192,15 +222,23 @@ export function readTmuxSessionTagsForGc(
 	sessionName: string,
 	env: NodeJS.ProcessEnv = process.env,
 ): GjcTmuxSessionTagsForGc {
+	const session = listGjcTmuxSessions(env).find(candidate => candidate.name === sessionName);
 	return {
 		profile: readExactOptionForGc(sessionName, GJC_TMUX_PROFILE_OPTION, env),
 		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),
+		createdAt: session?.createdAt,
+		attached: session?.attached,
+		panePids: session?.panePids,
 	};
 }
 
 export function removeGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
 	const session = statusGjcTmuxSession(sessionName, env);
+	if (session.attached || session.panePids.length > 0) {
+		throw new Error(`gjc_tmux_session_live:${sessionName}`);
+	}
 	if (readProfileForExactTarget(session.name, env) !== GJC_TMUX_PROFILE_VALUE) {
 		throw new Error(`gjc_tmux_session_not_managed:${sessionName}`);
 	}

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

@@ -1247,7 +1247,7 @@ const CLI_REPLAY_MAX_OUTPUT_BYTES = 1024 * 1024;
 const CLI_REPLAY_DEFAULT_TIMEOUT_MS = 10_000;
 const CLI_REPLAY_MIN_TIMEOUT_MS = 1_000;
 const CLI_REPLAY_MAX_TIMEOUT_MS = 30_000;
-const CLI_REPLAY_EXEMPT_REASON_CODES = new Set([
+const CLI_REPLAY_EXEMPT_REASON_CODES = [
 	"unsafe_side_effect",
 	"requires_credentials",
 	"requires_network",
@@ -1255,8 +1255,10 @@ const CLI_REPLAY_EXEMPT_REASON_CODES = new Set([
 	"destructive",
 	"interactive_only",
 	"platform_unavailable",
-]);
+] as const;
+const CLI_REPLAY_EXEMPT_REASON_CODE_SET = new Set<string>(CLI_REPLAY_EXEMPT_REASON_CODES);
 const CLI_REPLAY_ENV_BASE: Record<string, string> = { CI: "1", NO_COLOR: "1", GJC_ULTRAGOAL_REPLAY: "1" };
+const CLI_REPLAY_EXEMPT_REASON_CODE_LIST = CLI_REPLAY_EXEMPT_REASON_CODES.join(", ");
 const CLI_REPLAY_SAFE_ENV_NAMES = new Set(["LANG", "LC_ALL", "LC_CTYPE", "TZ"]);
 const CLI_REPLAY_DANGEROUS_ENV_NAME_PATTERN =
 	/^(?:NODE_OPTIONS|GIT_EXTERNAL_DIFF|GIT_SSH|GIT_SSH_COMMAND|GIT_PAGER|PATH|LD_PRELOAD|LD_LIBRARY_PATH)$|^(?:GIT_CONFIG|DYLD_|BUN_|NPM_CONFIG_)|(?:^|_)OPTIONS$|PRELOAD$/;
@@ -1568,8 +1570,10 @@ async function validateReplayExemptFallback(
 	const exempt = qualityGateObject(record.replayExempt);
 	if (!exempt) return false;
 	const reasonCode = requiredStringField(exempt, "reasonCode", `${fieldName}.replayExempt`);
-	if (!CLI_REPLAY_EXEMPT_REASON_CODES.has(reasonCode))
-		throw new Error(`qualityGate ${fieldName}.replayExempt.reasonCode is not recognized`);
+	if (!CLI_REPLAY_EXEMPT_REASON_CODE_SET.has(reasonCode))
+		throw new Error(
+			`qualityGate ${fieldName}.replayExempt.reasonCode must be one of: ${CLI_REPLAY_EXEMPT_REASON_CODE_LIST}`,
+		);
 	const reason = requiredStringField(exempt, "reason", `${fieldName}.replayExempt`);
 	if (!isSubstantiveEvidence(reason) || reason.length < 30)
 		throw new Error(`qualityGate ${fieldName}.replayExempt.reason must be audited and substantive`);

package/src/internal-urls/artifact-protocol.ts

@@ -63,7 +63,16 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 			throw new Error(`artifact://${id} not found`);
 		}
 
-		const content = await Bun.file(foundPath).text();
+		// F20: cap the materialized artifact so reading a huge spilled artifact cannot
+		// buffer GBs into memory (the range selector is applied downstream, so without a
+		// cap a `artifact://id:range` over a multi-GB artifact still reads it whole).
+		const MAX_ARTIFACT_READ_BYTES = 16 * 1024 * 1024;
+		const file = Bun.file(foundPath);
+		const fullSize = file.size;
+		const content =
+			fullSize > MAX_ARTIFACT_READ_BYTES
+				? `${await file.slice(0, MAX_ARTIFACT_READ_BYTES).text()}\n\n[Artifact truncated: first ${MAX_ARTIFACT_READ_BYTES} of ${fullSize} bytes shown; use a narrower range or a specialized tool for the full content.]`
+				: await file.text();
 		return {
 			url: url.href,
 			content,