@gajae-code/coding-agent 0.5.1 → 0.5.3

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

@@ -8,9 +8,10 @@ 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,
 	listTmuxSessionsForGc,
 	readTmuxSessionTagsForGc,
 	removeGjcTmuxSession,
@@ -18,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 {
@@ -64,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,
@@ -112,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));
 }
@@ -124,7 +174,7 @@ export const tmuxSessionsGcAdapter: GcStoreAdapter = {
 	async collect(ctx: GcContext): Promise<GcCollectResult> {
 		const records: GcRecord[] = [];
 		const errors: GcCollectResult["errors"] = [];
-		let sessions: ReturnType<typeof listTmuxSessionsForGc>;
+		let sessions: GjcTmuxSessionsForGc;
 		try {
 			sessions = listTmuxSessionsForGc(ctx.env);
 		} catch (error) {
@@ -153,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 };
@@ -164,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-guard.ts

@@ -32,6 +32,16 @@ export interface UltragoalGuardDiagnostic {
 	goalId?: string;
 }
 
+export interface UltragoalAskBlockDiagnostic {
+	active: boolean;
+	reason: string;
+	source: "absent" | "durable_state" | "durable_state_unreadable" | "ledger" | "goals_json";
+	goalsPath?: string;
+	ledgerPath?: string;
+	goalIds?: string[];
+	message: string;
+}
+
 export interface CurrentGoalLike {
 	objective: string;
 	status?: string;
@@ -70,6 +80,48 @@ async function hasDurableUltragoalState(cwd: string): Promise<boolean> {
 	}
 }
 
+function isEnoent(error: unknown): boolean {
+	return (
+		typeof error === "object" && error !== null && "code" in error && (error as { code?: unknown }).code === "ENOENT"
+	);
+}
+
+function activeAskDiagnostic(input: {
+	reason: string;
+	source: UltragoalAskBlockDiagnostic["source"];
+	goalsPath?: string;
+	ledgerPath?: string;
+	goalIds?: string[];
+}): UltragoalAskBlockDiagnostic {
+	return {
+		active: true,
+		reason: input.reason,
+		source: input.source,
+		goalsPath: input.goalsPath,
+		ledgerPath: input.ledgerPath,
+		goalIds: input.goalIds,
+		message: `${input.reason} Use \`gjc ultragoal record-review-blockers\` instead of asking the user.`,
+	};
+}
+
+function inactiveAskDiagnostic(input: {
+	reason: string;
+	source: UltragoalAskBlockDiagnostic["source"];
+	goalsPath?: string;
+	ledgerPath?: string;
+	goalIds?: string[];
+}): UltragoalAskBlockDiagnostic {
+	return {
+		active: false,
+		reason: input.reason,
+		source: input.source,
+		goalsPath: input.goalsPath,
+		ledgerPath: input.ledgerPath,
+		goalIds: input.goalIds,
+		message: input.reason,
+	};
+}
+
 function requiredGoals(plan: UltragoalPlan): UltragoalGoal[] {
 	return plan.goals.filter(goal => goal.status !== "superseded");
 }
@@ -278,6 +330,109 @@ export async function readUltragoalVerificationState(input: {
 	return receiptDiagnostic;
 }
 
+export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic> {
+	const paths = getUltragoalPaths(cwd);
+	try {
+		await fs.stat(paths.dir);
+	} catch (error) {
+		if (isEnoent(error)) {
+			return inactiveAskDiagnostic({
+				reason: "No durable .gjc/ultragoal state exists.",
+				source: "absent",
+				goalsPath: paths.goalsPath,
+				ledgerPath: paths.ledgerPath,
+			});
+		}
+		return activeAskDiagnostic({
+			reason: `Durable .gjc/ultragoal state is present but unreadable: ${error instanceof Error ? error.message : String(error)}`,
+			source: "durable_state_unreadable",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+		});
+	}
+
+	let plan: UltragoalPlan | null;
+	let ledger: UltragoalLedgerEvent[];
+	try {
+		plan = await readUltragoalPlan(cwd);
+		ledger = await readUltragoalLedger(cwd);
+	} catch (error) {
+		return activeAskDiagnostic({
+			reason: `Unable to read durable Ultragoal state: ${error instanceof Error ? error.message : String(error)}`,
+			source: "durable_state_unreadable",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+		});
+	}
+	if (!plan) {
+		return activeAskDiagnostic({
+			reason: "Durable .gjc/ultragoal state exists but goals.json is missing or empty.",
+			source: "durable_state_unreadable",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+		});
+	}
+
+	if (plan.goals.some(goal => goal.status === "review_blocked")) {
+		const goalIds = plan.goals.filter(goal => goal.status === "review_blocked").map(goal => goal.id);
+		return activeAskDiagnostic({
+			reason: `Ultragoal has recorded review blockers: ${goalIds.join(", ")}.`,
+			source: "goals_json",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+			goalIds,
+		});
+	}
+
+	const runState = getUltragoalRunCompletionState(plan);
+	if (runState.incompleteGoals.length > 0) {
+		const goalIds = runState.incompleteGoals.map(goal => goal.id);
+		return activeAskDiagnostic({
+			reason: `Ultragoal has incomplete required goals: ${goalIds.join(", ")}.`,
+			source: "goals_json",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+			goalIds,
+		});
+	}
+
+	const finalReceiptGoal = [...requiredGoals(plan)]
+		.reverse()
+		.find(goal => goal.completionVerification?.receiptKind === "final-aggregate");
+	if (!finalReceiptGoal) {
+		return activeAskDiagnostic({
+			reason: "Ultragoal aggregate completion is missing a final aggregate receipt.",
+			source: "durable_state",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+			goalIds: requiredGoals(plan).map(goal => goal.id),
+		});
+	}
+
+	const diagnostic = validateCompletionReceipt({
+		plan,
+		ledger,
+		goal: finalReceiptGoal,
+		receiptKind: "final-aggregate",
+	});
+	if (diagnostic.state !== "active_verified_complete") {
+		return activeAskDiagnostic({
+			reason: diagnostic.message,
+			source: diagnostic.state === "active_dirty_quality_gate" ? "ledger" : "durable_state",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+			goalIds: diagnostic.goalId ? [diagnostic.goalId] : undefined,
+		});
+	}
+	return inactiveAskDiagnostic({
+		reason: "Ultragoal run is verified complete.",
+		source: "durable_state",
+		goalsPath: paths.goalsPath,
+		ledgerPath: paths.ledgerPath,
+		goalIds: [finalReceiptGoal.id],
+	});
+}
+
 export async function assertCanCompleteCurrentGoal(input: {
 	cwd: string;
 	currentGoal?: CurrentGoalLike | null;