@gajae-code/coding-agent 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [0.7.5] - 2026-06-27
+
+### Fixed
+
+- Guarded `parentId` session-tree walks against cycles to stop resume from exhausting memory (OOM) on self-referential or cyclic parent chains (#1193).
+- Guarded `getTree` against child cycles so cyclic child references can no longer drive unbounded traversal (#1195).
+- Elided runaway thinking-token loops in the assistant message renderer so repeated thinking output no longer grows without bound (#1196).
+- Made `gjc session` create/list work on psmux-backed multiplexers (#1192).
+- Sanitized dot-prefixed cwd window titles so tmux window names render correctly (#1198).
+
 ## [0.7.4] - 2026-06-27
 
 ### Added

package/dist/types/gjc-runtime/tmux-common.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedTmuxBinary } from "./psmux-detect";
 export declare const GJC_DEFAULT_TMUX_SESSION = "gajae_code";
 export declare const GJC_TMUX_SESSION_PREFIX = "gajae_code_";
 export declare const GJC_TMUX_COMMAND_ENV = "GJC_TMUX_COMMAND";
@@ -11,6 +12,7 @@ export declare const GJC_TMUX_PROJECT_OPTION = "@gjc-project";
 export declare const GJC_TMUX_SESSION_ID_OPTION = "@gjc-session-id";
 export declare const GJC_TMUX_SESSION_STATE_FILE_OPTION = "@gjc-session-state-file";
 export declare const GJC_TMUX_VERSION_OPTION = "@gjc-version";
+export declare const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 export interface GjcTmuxProfileCommand {
     description: string;
     args: string[];
@@ -53,7 +55,11 @@ export { clearPsmuxDetectionCache, detectPsmux, probePsmux, resolveGjcTmuxBinary
  * keeps the exact-session match while giving tmux the window-qualified target
  * those commands require. See gajae-code#580.
  */
-export declare function buildGjcTmuxExactOptionTarget(sessionName: string): string;
+export declare function buildGjcTmuxExactOptionTarget(sessionName: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    binary?: ResolvedTmuxBinary;
+}): string;
 export declare const GJC_TMUX_UNTAGGED_REASON = "gjc_tmux_session_untagged";
 export declare function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string;
 export declare function buildGjcTmuxUntaggedSessionError(sessionName: string, tmuxCommand: string): string;
@@ -79,5 +85,8 @@ export declare function buildGjcTmuxProfileCommands(target: string, env?: NodeJS
     sessionId?: string | null;
     sessionStateFile?: string | null;
     version?: string | null;
+}, opts?: {
+    platform?: NodeJS.Platform;
+    tmuxCommand?: string;
 }): GjcTmuxProfileCommand[];
 export declare function normalizeTmuxCreatedAt(raw: string): string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.7.4",
+	"version": "0.7.5",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -52,12 +52,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.7.4",
-		"@gajae-code/agent-core": "0.7.4",
-		"@gajae-code/ai": "0.7.4",
-		"@gajae-code/natives": "0.7.4",
-		"@gajae-code/tui": "0.7.4",
-		"@gajae-code/utils": "0.7.4",
+		"@gajae-code/stats": "0.7.5",
+		"@gajae-code/agent-core": "0.7.5",
+		"@gajae-code/ai": "0.7.5",
+		"@gajae-code/natives": "0.7.5",
+		"@gajae-code/tui": "0.7.5",
+		"@gajae-code/utils": "0.7.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

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

@@ -34,25 +34,6 @@ export const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
 export const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 
-function envFlagDisabled(value: string | undefined): boolean {
-	const normalized = value?.trim().toLowerCase();
-	return normalized === "0" || normalized === "false" || normalized === "off" || normalized === "no";
-}
-
-/**
- * Decide whether the mouse / clipboard / mode-style UX profile commands should
- * be dropped for the active multiplexer. Psmux historically does not
- * round-trip every user option perfectly; the ownership-tag round-trip is the
- * only piece gjc session / gjc team actually need, so dropping the rest keeps
- * native Windows `gjc --tmux` bootable when those UX options would otherwise
- * hard-fail.
- */
-function psmuxProfileCommandsShouldDropUx(env: NodeJS.ProcessEnv, tmuxCommand: string): boolean {
-	if (envFlagDisabled(env[GJC_PSMUX_PROFILE_FORCE_ENV])) return false;
-	const resolved = resolveGjcTmuxBinary({ env });
-	return resolved.command === tmuxCommand && resolved.isPsmux;
-}
-
 type LaunchPolicy = "direct" | "tmux";
 
 interface TtyState {
@@ -232,25 +213,26 @@ function buildWindowsPowerShellInnerCommand(context: CommandResolutionContext, r
 export function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProfileResult {
 	const env = context.env ?? process.env;
 	const branchSlug = context.branch ? buildGjcTmuxSessionSlug(context.branch) : (context.branchSlug ?? null);
-	let commands = buildGjcTmuxProfileCommands(context.target, env, {
-		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,
-		version: context.version ?? null,
-	});
-	if (psmuxProfileCommandsShouldDropUx(env, context.tmuxCommand)) {
-		// Keep the ownership-tag round-trip (required for `gjc session` and
-		// `gjc team`); drop only the UX profile commands whose option keys
-		// historically do not round-trip cleanly on psmux.
-		const dropArgs = new Set(["mouse", "set-clipboard", "mode-style"]);
-		commands = commands.filter(command => {
-			const flag = command.args[0];
-			const key = command.args[command.args.length - 2];
-			return !(dropArgs.has(String(key)) && (flag === "set-option" || flag === "set-window-option"));
-		});
-	}
+	// The psmux UX filter (mouse / set-clipboard / mode-style /
+	// set-window-option) now lives in buildGjcTmuxProfileCommands so every
+	// caller — gjc --tmux planning, gjc session create, gjc team bootstrap —
+	// applies the same drop set when the active multiplexer is psmux. We pass
+	// the resolved tmuxCommand through the new opts seam so the filter
+	// engages for this exact command, not whatever the resolver returns at
+	// profile-build time.
+	const commands = buildGjcTmuxProfileCommands(
+		context.target,
+		env,
+		{
+			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,
+			version: context.version ?? null,
+		},
+		{ tmuxCommand: context.tmuxCommand },
+	);
 	if (commands.length === 0) return { skipped: true, commands: [], failures: [] };
 	const spawnSync = context.spawnSync ?? defaultSpawnSync;
 	const cwd = context.cwd ?? process.cwd();
@@ -324,8 +306,15 @@ function truncateVisibleTail(value: string, maxWidth: number): string {
 	return `…${result}`;
 }
 
+function sanitizeTmuxWindowProjectName(project: string): string {
+	const trimmed = project.trim();
+	if (!trimmed || /^\.+$/.test(trimmed)) return "gjc";
+	if (trimmed.startsWith(".")) return `dot-${trimmed.replace(/^\.+/, "")}`;
+	return trimmed;
+}
+
 export function buildGjcTmuxWindowTitle(cwd: string, branch: string | null | undefined): string {
-	const project = path.basename(path.resolve(cwd)) || "gjc";
+	const project = sanitizeTmuxWindowProjectName(path.basename(path.resolve(cwd)) || "gjc");
 	const trimmedBranch = branch?.trim();
 	if (!trimmedBranch) return truncateVisible(project, GJC_TMUX_WINDOW_LABEL_MAX_WIDTH);
 

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

@@ -1,3 +1,4 @@
+import type { ResolvedTmuxBinary } from "./psmux-detect";
 import { resolveGjcTmuxBinary } from "./psmux-detect";
 
 export const GJC_DEFAULT_TMUX_SESSION = "gajae_code";
@@ -13,6 +14,7 @@ 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_VERSION_OPTION = "@gjc-version";
+export const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 
 export interface GjcTmuxProfileCommand {
 	description: string;
@@ -70,7 +72,17 @@ export { clearPsmuxDetectionCache, detectPsmux, probePsmux, resolveGjcTmuxBinary
  * keeps the exact-session match while giving tmux the window-qualified target
  * those commands require. See gajae-code#580.
  */
-export function buildGjcTmuxExactOptionTarget(sessionName: string): string {
+export function buildGjcTmuxExactOptionTarget(
+	sessionName: string,
+	opts: { env?: NodeJS.ProcessEnv; platform?: NodeJS.Platform; binary?: ResolvedTmuxBinary } = {},
+): string {
+	const binary = opts.binary ?? resolveGjcTmuxBinary({ env: opts.env, platform: opts.platform });
+	// psmux 3.3.0 rejects the tmux `=NAME` exact-session prefix for option
+	// commands ("no server running on session '=NAME'"); bare `NAME` and
+	// window-qualified `NAME:` both work. tmux 3.6a needs the
+	// window-qualified `=NAME:` to resolve the session for option
+	// commands (gajae-code#580).
+	if (binary.isPsmux) return sessionName;
 	return `=${sessionName}:`;
 }
 
@@ -171,6 +183,16 @@ export function buildGjcTmuxRequiredProfileCommands(
 	return commands;
 }
 
+/**
+ * Keys whose set-option / set-window-option round-trip is unreliable on psmux
+ * 3.3.0. psmux does not support the tmux `set-window-option` command at all
+ * (it reports "unknown command: set-window-option") and silently drops several
+ * `set-option` keys. The list lives here so every code path that tags a tmux
+ * session (gjc --tmux planning, gjc session create, gjc team bootstrap)
+ * applies the same filter.
+ */
+const PSMUX_UNSUPPORTED_PROFILE_KEYS = new Set(["mouse", "set-clipboard", "mode-style"]);
+
 export function buildGjcTmuxProfileCommands(
 	target: string,
 	env: NodeJS.ProcessEnv = process.env,
@@ -182,6 +204,7 @@ export function buildGjcTmuxProfileCommands(
 		sessionStateFile?: string | null;
 		version?: string | null;
 	} = {},
+	opts: { platform?: NodeJS.Platform; tmuxCommand?: string } = {},
 ): GjcTmuxProfileCommand[] {
 	const commands = buildGjcTmuxRequiredProfileCommands(target, metadata);
 	if (envDisabled(env[GJC_TMUX_PROFILE_ENV])) return commands;
@@ -197,6 +220,40 @@ export function buildGjcTmuxProfileCommands(
 			description: "enable tmux mouse scrolling",
 			args: ["set-option", "-t", target, "mouse", "on"],
 		});
+	// psmux does not implement set-window-option and historically drops
+	// mouse / set-clipboard / mode-style. Filter the UX profile commands
+	// centrally so every code path that tags a session (gjc --tmux planning,
+	// gjc session create, gjc team bootstrap) drops the same set. The
+	// GJC_PSMUX_PROFILE_FORCE override lets the operator opt back in when
+	// running on a psmux build that has caught up. The ownership-tag
+	// round-trip (set-option @gjc-*) is never filtered, since gjc session /
+	// gjc team rely on it.
+	// The filter is opt-in: callers that explicitly pass `opts.tmuxCommand`
+	// name a psmux-class multiplexer (psmux / pmux) when they want the UX
+	// profile filtered. Auto-detect on Windows hosts where psmux happens
+	// to be on PATH would silently change the test output for every caller
+	// that does not pin the multiplexer, so we require the caller to opt
+	// in by naming the multiplexer. GJC_PSMUX_PROFILE_FORCE re-enables
+	// the UX profile commands when a psmux build catches up.
+	const tmuxName = (opts.tmuxCommand ?? "").toLowerCase();
+	const isPsmuxClass =
+		tmuxName === "psmux" ||
+		tmuxName === "pmux" ||
+		tmuxName.endsWith("/psmux") ||
+		tmuxName.endsWith("/pmux") ||
+		tmuxName.endsWith("\\psmux") ||
+		tmuxName.endsWith("\\pmux");
+	const dropUx = isPsmuxClass && !envDisabled(env[GJC_PSMUX_PROFILE_FORCE_ENV]);
+	if (dropUx) {
+		return commands.filter(command => {
+			const flag = command.args[0];
+			const key = command.args[command.args.length - 2];
+			return !(
+				PSMUX_UNSUPPORTED_PROFILE_KEYS.has(String(key)) &&
+				(flag === "set-option" || flag === "set-window-option")
+			);
+		});
+	}
 	return commands;
 }
 

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

@@ -1,3 +1,4 @@
+import { resolveGjcTmuxBinary } from "./psmux-detect";
 import {
 	buildGjcTmuxExactOptionTarget,
 	buildGjcTmuxProfileCommands,
@@ -128,10 +129,29 @@ function runListSessions(format: string, env: NodeJS.ProcessEnv = process.env):
 		}
 		throw error;
 	}
-	return output
+	const lines = output
 		.split("\n")
 		.map(line => line.trim())
 		.filter(Boolean);
+	// psmux 3.3.0 silently ignores the tmux `-F` format flag and returns its
+	// default `name: N windows (created ...)` shape. Detect that case and
+	// synthesize a tab-separated row so downstream parseSessionLine /
+	// hydrateSessionFromExactOptions can recover the @gjc-* ownership tags
+	// via follow-up show-options calls. Without this fallback gjc session
+	// list / status return an empty list on psmux even when sessions exist.
+	if (lines.length > 0 && !lines[0].includes("\t")) {
+		const binary = resolveGjcTmuxBinary({ env });
+		if (binary.isPsmux) {
+			return lines.map(line => {
+				const match = line.match(/^([^:]+):\s*(\d+)\s+windows?\s+\(created\s+([^)]+)\)/);
+				if (!match) return line;
+				const [, name, windows, created] = match;
+				const createdEpoch = String(Math.floor(new Date(`${created} UTC`).getTime() / 1000) || 0);
+				return [name, windows, "0", createdEpoch, "", "", "0", "", "", "", "", "", "", ""].join("\t");
+			});
+		}
+	}
+	return lines;
 }
 
 function listSessionLines(env: NodeJS.ProcessEnv = process.env): string[] {
@@ -235,7 +255,14 @@ export function createGjcTmuxSession(env: NodeJS.ProcessEnv = process.env): GjcT
 	});
 	if (created.exitCode !== 0) throw new Error(created.stderr.toString().trim() || "gjc_tmux_session_create_failed");
 	try {
-		for (const profileCommand of buildGjcTmuxProfileCommands(sessionName, env)) {
+		// psmux 3.3.0 rejects the tmux `=NAME` exact-session prefix for option
+		// commands, so the target is the bare session name on psmux and the
+		// window-qualified `=NAME:` on tmux. The ownership-tag round-trip
+		// (set-option @gjc-*) is preserved on both; only the UX profile commands
+		// (mouse / set-clipboard / mode-style / set-window-option) get filtered
+		// by buildGjcTmuxProfileCommands when the active binary is psmux.
+		const target = buildGjcTmuxExactOptionTarget(sessionName, { env });
+		for (const profileCommand of buildGjcTmuxProfileCommands(target, env, {}, { tmuxCommand })) {
 			runTmux(profileCommand.args, env);
 		}
 	} catch (error) {
@@ -246,18 +273,43 @@ export function createGjcTmuxSession(env: NodeJS.ProcessEnv = process.env): GjcT
 }
 
 function readProfileForExactTarget(sessionName: string, env: NodeJS.ProcessEnv): string {
-	return runTmux(
-		["show-options", "-qv", "-t", buildGjcTmuxExactOptionTarget(sessionName), GJC_TMUX_PROFILE_OPTION],
+	const raw = runTmux(
+		["show-options", "-qv", "-t", buildGjcTmuxExactOptionTarget(sessionName, { env }), GJC_TMUX_PROFILE_OPTION],
 		env,
 	).trim();
+	// tmux returns just the value; psmux returns `key value`. Strip the
+	// leading key on psmux so the GJC_TMUX_PROFILE_VALUE equality check
+	// against "1" works the same on both.
+	if (raw && resolveGjcTmuxBinary({ env }).isPsmux) {
+		const tokens = raw.split(/\s+/).filter(Boolean);
+		return tokens[tokens.length - 1] ?? raw;
+	}
+	return raw;
 }
 
 function readExactOptionForGc(sessionName: string, option: string, env: NodeJS.ProcessEnv): string | undefined {
 	try {
-		return (
-			runTmux(["show-options", "-qv", "-t", buildGjcTmuxExactOptionTarget(sessionName), option], env).trim() ||
-			undefined
-		);
+		const raw = runTmux(
+			["show-options", "-qv", "-t", buildGjcTmuxExactOptionTarget(sessionName, { env }), option],
+			env,
+		).trim();
+		if (!raw) return undefined;
+		// tmux returns just the option value (e.g. `1` for @gjc-profile).
+		// psmux 3.3.0 returns `key value` (or `key "value with space"` for
+		// @gjc-branch etc.). On psmux, parse the last token and strip any
+		// surrounding double quotes so both shapes resolve to the same value.
+		if (resolveGjcTmuxBinary({ env }).isPsmux) {
+			// Prefer the last whitespace-separated token. If the value is
+			// quoted, find the matching close-quote and slice.
+			const lastQuote = raw.lastIndexOf('"');
+			if (lastQuote > 0 && raw[lastQuote - 1] !== "\\") {
+				const firstQuote = raw.lastIndexOf('"', lastQuote - 1);
+				if (firstQuote > 0) return raw.slice(firstQuote + 1, lastQuote);
+			}
+			const tokens = raw.split(/\s+/).filter(Boolean);
+			return tokens[tokens.length - 1];
+		}
+		return raw;
 	} catch {
 		return undefined;
 	}

package/src/modes/components/assistant-message.ts

@@ -7,6 +7,54 @@ import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { isSilentAbort } from "../../session/messages";
 import { resolveImageOptions } from "../../tools/render-utils";
 
+const THINKING_REPETITION_ELIDE_MIN_RUN = 24;
+const THINKING_REPETITION_VISIBLE_TOKENS = 3;
+const THINKING_REPETITION_TOKEN_PATTERN = /[\p{L}\p{N}_'-]{1,32}/gu;
+
+interface ThinkingRepetitionToken {
+	text: string;
+	normalized: string;
+	start: number;
+	end: number;
+}
+
+function elideRunawayThinkingRepetition(text: string): string {
+	const tokens: ThinkingRepetitionToken[] = [];
+	for (const match of text.matchAll(THINKING_REPETITION_TOKEN_PATTERN)) {
+		if (match.index === undefined) continue;
+		tokens.push({
+			text: match[0],
+			normalized: match[0].toLocaleLowerCase("en-US"),
+			start: match.index,
+			end: match.index + match[0].length,
+		});
+	}
+
+	let runStart = 0;
+	for (let i = 1; i <= tokens.length; i++) {
+		const current = tokens[i];
+		const previous = tokens[i - 1];
+		if (current && previous && current.normalized === previous.normalized) continue;
+
+		const runLength = i - runStart;
+		if (runLength >= THINKING_REPETITION_ELIDE_MIN_RUN) {
+			const first = tokens[runStart];
+			const last = tokens[i - 1];
+			if (!first || !last) return text;
+
+			const visibleCount = Math.min(THINKING_REPETITION_VISIBLE_TOKENS, runLength);
+			const visible = Array.from({ length: visibleCount }, () => first.text).join(" ");
+			const omitted = runLength - visibleCount;
+			const marker = `${visible} … [thinking loop elided: "${first.text}" repeated ${omitted} more times]`;
+			return `${text.slice(0, first.start)}${marker}${text.slice(last.end)}`.trim();
+		}
+
+		runStart = i;
+	}
+
+	return text;
+}
+
 /**
  * Component that renders a complete assistant message
  */
@@ -128,7 +176,7 @@ export class AssistantMessageComponent extends Container {
 	#renderThinkingBlock(content: { thinking: string }): Markdown {
 		const cached = this.#contentBlocksCache.get(content);
 		if (cached?.source === content.thinking) return cached.component as Markdown;
-		const trimmed = content.thinking.trim();
+		const trimmed = elideRunawayThinkingRepetition(content.thinking.trim());
 		const component = new Markdown(trimmed, 1, 0, getMarkdownTheme(), {
 			color: (text: string) => theme.fg("thinkingText", text),
 			italic: true,

package/src/session/session-manager.ts

@@ -640,8 +640,11 @@ export function buildSessionContext(
 
 	// Walk from leaf to root, then reverse once to avoid repeated front insertions on long branches.
 	const path: SessionEntry[] = [];
+	const visited = new Set<string>();
 	let current: SessionEntry | undefined = leaf;
 	while (current) {
+		if (visited.has(current.id)) break;
+		visited.add(current.id);
 		path.push(current);
 		current = current.parentId ? byId.get(current.parentId) : undefined;
 	}
@@ -3988,8 +3991,11 @@ export class SessionManager {
 	 * Returns undefined if no model change has been recorded.
 	 */
 	getLastModelChangeRole(): string | undefined {
+		const visited = new Set<string>();
 		let current = this.getLeafEntry();
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			if (current.type === "model_change") {
 				return current.role ?? "default";
 			}
@@ -4005,8 +4011,11 @@ export class SessionManager {
 		if (!compaction || compaction.type !== "compaction")
 			throw new Error(`Compaction entry ${compactionEntryId} not found`);
 		const ids: string[] = [];
+		const visited = new Set<string>();
 		let current: SessionEntry | undefined = compaction;
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			ids.push(current.id);
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
@@ -4155,8 +4164,11 @@ export class SessionManager {
 	getBranchForFidelity(fromId?: string): SessionEntry[] {
 		const cache = new Map<string, string>();
 		const path: SessionEntry[] = [];
+		const visited = new Set<string>();
 		let current = (fromId ?? this.#leafId) ? this.#byId.get(fromId ?? this.#leafId ?? "") : undefined;
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			path.push(
 				rehydrateColdSpillEntry(
 					materializeResidentEntrySync(current, this.#residentBlobStores(), cache),
@@ -4172,8 +4184,11 @@ export class SessionManager {
 
 	#getCanonicalBranchClones(fromId?: string): SessionEntry[] {
 		const path: SessionEntry[] = [];
+		const visited = new Set<string>();
 		let current = (fromId ?? this.#leafId) ? this.#byId.get(fromId ?? this.#leafId ?? "") : undefined;
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			path.push(cloneSessionEntry(current));
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
@@ -4267,9 +4282,12 @@ export class SessionManager {
 		this.#getBranchMaterializerCallCount++;
 		const cache = new Map<string, string>();
 		const path: SessionEntry[] = [];
+		const visited = new Set<string>();
 		const startId = fromId ?? this.#leafId;
 		let current = startId ? this.#byId.get(startId) : undefined;
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			path.push(materializeResidentEntrySync(current, this.#residentBlobStores(), cache));
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
@@ -4303,8 +4321,11 @@ export class SessionManager {
 	#getActivePathEntriesForProviderContext(fromId?: string | null): SessionEntry[] {
 		if (fromId === null || (fromId === undefined && this.#leafId === null)) return [];
 		const ids: string[] = [];
+		const visited = new Set<string>();
 		let current = this.#byId.get(fromId ?? this.#leafId ?? "");
 		while (current) {
+			if (visited.has(current.id)) break;
+			visited.add(current.id);
 			ids.push(current.id);
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
@@ -4418,18 +4439,48 @@ export class SessionManager {
 			nodeMap.set(entry.id, { entry, children: [], label });
 		}
 
-		// Build tree
+		const addRoot = (node: SessionTreeNode): void => {
+			if (!roots.includes(node)) {
+				roots.push(node);
+			}
+		};
+		const removeRoot = (node: SessionTreeNode): void => {
+			const index = roots.indexOf(node);
+			if (index !== -1) {
+				roots.splice(index, 1);
+			}
+		};
+		const wouldCreateChildCycle = (parent: SessionTreeNode, child: SessionTreeNode): boolean => {
+			const stack: SessionTreeNode[] = [child];
+			const visited = new Set<SessionTreeNode>();
+			while (stack.length > 0) {
+				const current = stack.pop()!;
+				if (current === parent) {
+					return true;
+				}
+				if (visited.has(current)) {
+					continue;
+				}
+				visited.add(current);
+				stack.push(...current.children);
+			}
+			return false;
+		};
+
+		// Build tree. Corrupt session files can contain duplicate IDs or parentId
+		// cycles; reject only the edge that would make the returned tree cyclic.
 		for (const entry of entries) {
 			const node = nodeMap.get(entry.id)!;
 			if (entry.parentId === null || entry.parentId === entry.id) {
-				roots.push(node);
+				addRoot(node);
 			} else {
 				const parent = nodeMap.get(entry.parentId);
-				if (parent) {
+				if (parent && !wouldCreateChildCycle(parent, node)) {
 					parent.children.push(node);
+					removeRoot(node);
 				} else {
-					// Orphan - treat as root
-					roots.push(node);
+					// Orphan or cycle-closing edge - treat as root
+					addRoot(node);
 				}
 			}
 		}
@@ -4437,8 +4488,13 @@ export class SessionManager {
 		// Sort children by timestamp (oldest first, newest at bottom)
 		// Use iterative approach to avoid stack overflow on deep trees
 		const stack: SessionTreeNode[] = [...roots];
+		const sorted = new Set<SessionTreeNode>();
 		while (stack.length > 0) {
 			const node = stack.pop()!;
+			if (sorted.has(node)) {
+				continue;
+			}
+			sorted.add(node);
 			node.children.sort((a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime());
 			stack.push(...node.children);
 		}