ralph-review 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-review",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Orchestrating coding agents for code review, verification and fixing via the ralph loop.",
   "license": "MIT",
   "type": "module",

package/src/lib/review-workflow/review/run-review-session.ts

@@ -325,6 +325,20 @@ export async function runReviewSession(
     if (entry.type === "review_iteration") {
       latestPersistedFindings = [...latestPersistedFindings, ...entry.findings];
       completedReviewIterations = entry.iteration;
+
+      if (worktree && latestPersistedFindings.length > 0) {
+        await deps.saveFindingsArtifact(
+          CONFIG_DIR,
+          createFindingsArtifact(
+            sessionId,
+            projectPath,
+            sessionPath,
+            worktree,
+            latestPersistedFindings
+          )
+        );
+        shouldDeleteSessionRefs = false;
+      }
     }
   };
 

package/src/lib/stop-session.ts

@@ -1,5 +1,5 @@
 import { discardSessionWorktree, type GitSessionWorktree } from "@/lib/git";
-import { deleteSessionFiles, readLog } from "@/lib/logger";
+import { appendLog, deleteSessionFiles, readLog } from "@/lib/logger";
 import {
   type ActiveSession,
   readSessionState,
@@ -27,6 +27,7 @@ interface WaitForGracefulStopDeps {
 
 interface StopActiveSessionDeps {
   readLog: typeof readLog;
+  appendLog: typeof appendLog;
   deleteSessionFiles: typeof deleteSessionFiles;
   updateSessionState: typeof updateSessionState;
   sendInterrupt: typeof sendInterrupt;
@@ -41,6 +42,7 @@ interface StopActiveSessionDeps {
 
 const DEFAULT_STOP_ACTIVE_SESSION_DEPS: StopActiveSessionDeps = {
   readLog,
+  appendLog,
   deleteSessionFiles,
   updateSessionState,
   sendInterrupt,
@@ -137,6 +139,7 @@ interface SessionIterationState {
   hasRecordedIteration: boolean;
   hasRecordedReviewProgress: boolean;
   hasSuccessfulReviewIteration: boolean;
+  entries: LogEntry[];
 }
 
 async function resolveSessionIterationState(
@@ -153,12 +156,58 @@ async function resolveSessionIterationState(
       hasRecordedIteration: hasRecordedIteration(entries),
       hasRecordedReviewProgress: hasRecordedReviewProgress(entries),
       hasSuccessfulReviewIteration: hasSuccessfulReviewIteration(entries),
+      entries,
     };
   } catch {
     return null;
   }
 }
 
+function getLatestLifecycleEntry(entries: LogEntry[]): LogEntry | undefined {
+  return [...entries].reverse().find((entry) => entry.type !== "handoff");
+}
+
+function getLatestReviewIteration(entries: LogEntry[]) {
+  return entries.filter((entry) => entry.type === "review_iteration").at(-1);
+}
+
+function getAccumulatedReviewFindings(entries: LogEntry[]) {
+  return entries.flatMap((entry) => (entry.type === "review_iteration" ? entry.findings : []));
+}
+
+async function terminalizeForceStoppedReviewSession(
+  session: ActiveSession,
+  iterationState: SessionIterationState | null,
+  deps: StopActiveSessionDeps
+): Promise<void> {
+  if (!session.sessionPath || !iterationState?.hasRecordedReviewProgress) {
+    return;
+  }
+
+  if (getLatestLifecycleEntry(iterationState.entries)?.type === "session_end") {
+    return;
+  }
+
+  const latestReviewIteration = getLatestReviewIteration(iterationState.entries);
+  if (!latestReviewIteration) {
+    return;
+  }
+
+  await deps.appendLog(session.sessionPath, {
+    type: "session_end",
+    timestamp: Date.now(),
+    status: "interrupted",
+    reason: "Review stopped by user.",
+    iterations: latestReviewIteration.iteration,
+    phase: "review",
+    sessionStatus: "interrupted",
+    reviewOutcome:
+      getAccumulatedReviewFindings(iterationState.entries).length > 0
+        ? "findings-pending"
+        : "incomplete",
+  });
+}
+
 function createCleanupWorktree(
   session: ActiveSession,
   sourceRepoPath: string
@@ -239,6 +288,15 @@ export async function stopActiveSession(
   }
 
   const finalIterationState = await resolveSessionIterationState(session, stopDeps);
+  let terminalizeSessionError: unknown;
+  if (!stoppedGracefully) {
+    try {
+      await terminalizeForceStoppedReviewSession(session, finalIterationState, stopDeps);
+    } catch (error) {
+      terminalizeSessionError = error;
+    }
+  }
+
   if (finalIterationState?.hasSuccessfulReviewIteration === false) {
     cleanupUnpromotedSessionWorktree(session, stopDeps);
   }
@@ -256,6 +314,10 @@ export async function stopActiveSession(
     expectedSessionId: session.sessionId,
   });
 
+  if (terminalizeSessionError) {
+    throw terminalizeSessionError;
+  }
+
   if (deleteSessionFilesError) {
     throw deleteSessionFilesError;
   }

package/src/lib/tui/dashboard/Dashboard.tsx

@@ -11,15 +11,25 @@ import type { FocusedPane } from "@/lib/tui/workspace/workspace-types";
 import { DashboardOverlays } from "./DashboardOverlays";
 import { getPendingFixTarget } from "./dashboard-fix-state";
 import { cycleDashboardFocus, cycleDashboardFocusReverse } from "./dashboard-focus";
+import { resolveSelectedGroupPath, selectAdjacentGroupPath } from "./dashboard-group-selection";
 import { isDashboardOverlayBlockingFocus } from "./dashboard-overlay-state";
 import { Header } from "./Header";
 import { StatusBar } from "./StatusBar";
 import { useDashboardRunControl } from "./use-dashboard-run-control";
 import { useDashboardStopControl } from "./use-dashboard-stop-control";
 
-export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: DashboardProps) {
+export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }: DashboardProps) {
   const renderer = useRenderer();
-  const state = useWorkspaceState(projectPath, branch, refreshInterval);
+  const resolvedUseWorkspaceState = deps?.useWorkspaceState ?? useWorkspaceState;
+  const ResolvedDashboardOverlays = deps?.DashboardOverlays ?? DashboardOverlays;
+  const [selectedGroupPath, setSelectedGroupPath] = useState<string>(projectPath);
+  const state = resolvedUseWorkspaceState(
+    projectPath,
+    branch,
+    refreshInterval,
+    undefined,
+    selectedGroupPath
+  );
   const {
     runError,
     startupMode,
@@ -29,7 +39,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
     spawnRunProcess,
     spawnFixProcess,
     isStartupSpawning,
-  } = useDashboardRunControl(projectPath);
+  } = useDashboardRunControl(projectPath, { spawn: deps?.spawn });
   const [focusedPane, setFocusedPane] = useState<FocusedPane>("detail");
   const [outputVisible, setOutputVisible] = useState(false);
   const [showHelp, setShowHelp] = useState(false);
@@ -37,11 +47,14 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
   const [showSession, setShowSession] = useState(false);
   const [showReviewModeOverlay, setShowReviewModeOverlay] = useState(false);
   const [showStopPicker, setShowStopPicker] = useState(false);
-  const { isStoppingRun, stopSelectedSession } = useDashboardStopControl({
-    currentSession: state.currentSession,
-    setShowStopPicker,
-    onError: setRunError,
-  });
+  const { isStoppingRun, stopSelectedSession } = useDashboardStopControl(
+    {
+      currentSession: state.currentSession,
+      setShowStopPicker,
+      onError: setRunError,
+    },
+    { stopActiveSession: deps?.stopActiveSession }
+  );
 
   const projectName = basename(projectPath);
   const isExitingRef = useRef(false);
@@ -80,6 +93,15 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
     setShowFixFindings(false);
   }
 
+  const resolvedSelectedGroupPath = resolveSelectedGroupPath(
+    state.sessionGroups,
+    selectedGroupPath,
+    projectPath
+  );
+  if (resolvedSelectedGroupPath !== selectedGroupPath) {
+    setSelectedGroupPath(resolvedSelectedGroupPath);
+  }
+
   const shutdown = useCallback(
     async (after?: () => Promise<void>, exitCode: number = 0) => {
       if (isExitingRef.current) {
@@ -119,6 +141,18 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
     setFocusedPane((current) => cycleDashboardFocusReverse(current, outputVisible));
   }, [outputVisible]);
 
+  const selectPrevGroup = useCallback(() => {
+    setSelectedGroupPath((current) =>
+      selectAdjacentGroupPath(state.sessionGroups, current, "prev")
+    );
+  }, [state.sessionGroups]);
+
+  const selectNextGroup = useCallback(() => {
+    setSelectedGroupPath((current) =>
+      selectAdjacentGroupPath(state.sessionGroups, current, "next")
+    );
+  }, [state.sessionGroups]);
+
   const handleKeyboard = useCallback(
     (key: { name: string }) => {
       const action = resolveDashboardKeyAction({
@@ -132,6 +166,8 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
         hasCurrentSession: Boolean(state.currentSession),
         canFixPendingSession,
         isRunSpawning: isStartupSpawning(),
+        sidebarFocused: focusedPane === "sidebar",
+        sessionGroupCount: state.sessionGroups.length,
       });
 
       switch (action) {
@@ -182,6 +218,12 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
           clearRunError();
           setShowReviewModeOverlay(true);
           return;
+        case "select-prev-group":
+          selectPrevGroup();
+          return;
+        case "select-next-group":
+          selectNextGroup();
+          return;
       }
     },
     [
@@ -189,7 +231,10 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
       clearRunError,
       cycleFocus,
       cycleFocusReverse,
+      focusedPane,
       isStartupSpawning,
+      selectNextGroup,
+      selectPrevGroup,
       showFixFindings,
       showHelp,
       showReviewModeOverlay,
@@ -198,6 +243,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
       shutdown,
       state.allSessions,
       state.currentSession,
+      state.sessionGroups.length,
       stopSelectedSession,
     ]
   );
@@ -233,7 +279,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
         ) : (
           <Workspace
             sessionGroups={state.sessionGroups}
-            selectedSessionId={state.selectedSessionId}
+            selectedGroupPath={selectedGroupPath}
             session={state.currentSession}
             fixes={state.fixes}
             skipped={state.skipped}
@@ -271,7 +317,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
           liveRefreshError={state.liveRefreshError}
           configWarning={state.configWarning}
         />
-        <DashboardOverlays
+        <ResolvedDashboardOverlays
           showHelp={showHelp}
           showRunOverlay={showRunOverlay}
           showFixFindings={showFixFindings}

package/src/lib/tui/dashboard/dashboard-group-selection.ts

@@ -0,0 +1,34 @@
+import type { SessionGroupData } from "@/lib/tui/workspace/workspace-types";
+
+export function selectAdjacentGroupPath(
+  groups: SessionGroupData[],
+  currentPath: string,
+  direction: "prev" | "next"
+): string {
+  if (groups.length === 0) {
+    return currentPath;
+  }
+
+  const index = groups.findIndex((group) => group.projectPath === currentPath);
+  if (index < 0) {
+    return groups[0]?.projectPath ?? currentPath;
+  }
+
+  const delta = direction === "prev" ? -1 : 1;
+  const nextIndex = Math.min(groups.length - 1, Math.max(0, index + delta));
+  return groups[nextIndex]?.projectPath ?? currentPath;
+}
+
+export function resolveSelectedGroupPath(
+  groups: SessionGroupData[],
+  preferredPath: string,
+  fallbackPath: string
+): string {
+  if (groups.some((group) => group.projectPath === preferredPath)) {
+    return preferredPath;
+  }
+  if (groups.some((group) => group.projectPath === fallbackPath)) {
+    return fallbackPath;
+  }
+  return groups[0]?.projectPath ?? fallbackPath;
+}

package/src/lib/tui/dashboard/dashboard-keyboard.ts

@@ -17,7 +17,9 @@ export type DashboardKeyAction =
   | "open-session"
   | "stop-single-session"
   | "open-stop-picker"
-  | "open-review-mode";
+  | "open-review-mode"
+  | "select-prev-group"
+  | "select-next-group";
 
 interface ResolveDashboardCloseActionInput {
   showStopPicker: boolean;
@@ -63,6 +65,8 @@ interface ResolveDashboardKeyActionInput extends ResolveDashboardCloseActionInpu
   hasCurrentSession: boolean;
   canFixPendingSession: boolean;
   isRunSpawning: boolean;
+  sidebarFocused?: boolean;
+  sessionGroupCount?: number;
 }
 
 export function resolveDashboardKeyAction({
@@ -76,6 +80,8 @@ export function resolveDashboardKeyAction({
   hasCurrentSession,
   canFixPendingSession,
   isRunSpawning,
+  sidebarFocused = false,
+  sessionGroupCount = 0,
 }: ResolveDashboardKeyActionInput): DashboardKeyAction {
   if (keyName === "q" || keyName === "escape") {
     return resolveDashboardCloseAction({
@@ -91,6 +97,16 @@ export function resolveDashboardKeyAction({
     return "none";
   }
 
+  if (sidebarFocused && sessionGroupCount >= 2) {
+    if (keyName === "up" || keyName === "k") {
+      return "select-prev-group";
+    }
+
+    if (keyName === "down" || keyName === "j") {
+      return "select-next-group";
+    }
+  }
+
   if (keyName === "tab" || keyName === "right") {
     return "cycle-focus";
   }

package/src/lib/tui/dashboard/use-dashboard-run-control.ts

@@ -15,10 +15,18 @@ export interface DashboardRunControl {
   isStartupSpawning: () => boolean;
 }
 
-export function useDashboardRunControl(projectPath: string): DashboardRunControl {
+interface DashboardRunControlDeps {
+  spawn?: typeof Bun.spawn;
+}
+
+export function useDashboardRunControl(
+  projectPath: string,
+  deps?: DashboardRunControlDeps
+): DashboardRunControl {
   const [runError, setRunError] = useState<string | null>(null);
   const [startupMode, setStartupMode] = useState<DashboardStartupMode>(null);
   const isStartupSpawningRef = useRef(false);
+  const spawn = deps?.spawn ?? Bun.spawn;
 
   const clearRunError = useCallback(() => {
     setRunError(null);
@@ -40,7 +48,7 @@ export function useDashboardRunControl(projectPath: string): DashboardRunControl
       setStartupMode(nextStartupMode);
 
       try {
-        const subprocess = Bun.spawn([process.execPath, CLI_PATH, command, ...argv], {
+        const subprocess = spawn([process.execPath, CLI_PATH, command, ...argv], {
           cwd: projectPath,
           stdin: "ignore",
           stdout: "pipe",
@@ -73,7 +81,7 @@ export function useDashboardRunControl(projectPath: string): DashboardRunControl
         setRunError(getErrorMessage(error));
       }
     },
-    [projectPath]
+    [projectPath, spawn]
   );
 
   const spawnRunProcess = useCallback(

package/src/lib/tui/dashboard/use-dashboard-stop-control.ts

@@ -22,13 +22,17 @@ export interface DashboardStopControl {
   stopSelectedSession: (session: ActiveSession) => Promise<void>;
 }
 
-export function useDashboardStopControl({
-  currentSession,
-  setShowStopPicker,
-  onError,
-}: DashboardStopControlOptions): DashboardStopControl {
+interface DashboardStopControlDeps {
+  stopActiveSession?: typeof stopActiveSession;
+}
+
+export function useDashboardStopControl(
+  options: DashboardStopControlOptions,
+  deps?: DashboardStopControlDeps
+): DashboardStopControl {
   const [stoppingSession, setStoppingSession] = useState<StoppingSessionState | null>(null);
   const settleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const stopSession = deps?.stopActiveSession ?? stopActiveSession;
 
   const clearSettleTimer = useMemo(
     () => () => {
@@ -42,7 +46,10 @@ export function useDashboardStopControl({
 
   if (
     stoppingSession &&
-    shouldClearStoppingSessionState({ marker: stoppingSession, currentSession })
+    shouldClearStoppingSessionState({
+      marker: stoppingSession,
+      currentSession: options.currentSession,
+    })
   ) {
     clearSettleTimer();
     setStoppingSession(null);
@@ -57,8 +64,8 @@ export function useDashboardStopControl({
 
       try {
         await stopSelectedDashboardSession(session, {
-          setShowStopPicker,
-          stopActiveSession,
+          setShowStopPicker: options.setShowStopPicker,
+          stopActiveSession: stopSession,
         });
 
         const settled = settleStoppingSessionState(createStoppingSessionState(session));
@@ -78,10 +85,10 @@ export function useDashboardStopControl({
       } catch (error) {
         clearSettleTimer();
         setStoppingSession(null);
-        onError(getErrorMessage(error));
+        options.onError(getErrorMessage(error));
       }
     },
-    [clearSettleTimer, onError, setShowStopPicker]
+    [clearSettleTimer, options.onError, options.setShowStopPicker, stopSession]
   );
 
   return {

package/src/lib/tui/sessions/sidebar/SessionGroup.tsx

@@ -4,16 +4,21 @@ import { SessionItem } from "./SessionItem";
 
 interface SessionGroupProps {
   group: SessionGroupData;
-  selectedSessionId: string | null;
+  isSelected: boolean;
+  sidebarFocused?: boolean;
 }
 
-export function SessionGroup({ group, selectedSessionId }: SessionGroupProps) {
+export function SessionGroup({ group, isSelected, sidebarFocused = false }: SessionGroupProps) {
   const icon = group.isCurrentProject ? "◆" : "○";
-  const nameColor = group.isCurrentProject ? TUI_COLORS.text.primary : TUI_COLORS.text.muted;
+  const baseNameColor = group.isCurrentProject ? TUI_COLORS.text.primary : TUI_COLORS.text.muted;
+  const nameColor = isSelected ? TUI_COLORS.text.primary : baseNameColor;
+  const headerBg = isSelected ? (sidebarFocused ? "#1e293b" : "#111827") : undefined;
+  const caret = isSelected ? "›" : " ";
 
   return (
     <box flexDirection="column">
-      <box flexDirection="row" gap={1} paddingLeft={1}>
+      <box flexDirection="row" gap={1} paddingLeft={1} paddingRight={1} backgroundColor={headerBg}>
+        <text fg={isSelected ? TUI_COLORS.accent.key : TUI_COLORS.text.dim}>{caret}</text>
         <text fg={nameColor}>{icon}</text>
         <text fg={nameColor} wrapMode="none">
           <strong>{group.projectName}</strong>
@@ -23,12 +28,7 @@ export function SessionGroup({ group, selectedSessionId }: SessionGroupProps) {
         )}
       </box>
       {group.sessions.map((session) => (
-        <SessionItem
-          key={session.sessionId}
-          session={session}
-          isSelected={session.sessionId === selectedSessionId}
-          projectName={group.projectName}
-        />
+        <SessionItem key={session.sessionId} session={session} projectName={group.projectName} />
       ))}
       {group.sessions.length === 0 && (
         <text fg={TUI_COLORS.text.dim} paddingLeft={4}>

package/src/lib/tui/sessions/sidebar/SessionItem.tsx

@@ -3,7 +3,6 @@ import { TUI_COLORS } from "@/lib/tui/shared/colors";
 
 interface SessionItemProps {
   session: ActiveSession;
-  isSelected: boolean;
   projectName?: string;
 }
 
@@ -32,16 +31,14 @@ function getStatusIcon(state: string): { icon: string; color: string } {
   }
 }
 
-export function SessionItem({ session, isSelected, projectName }: SessionItemProps) {
+export function SessionItem({ session, projectName }: SessionItemProps) {
   const { icon, color } = getStatusIcon(session.state);
-  const bgColor = isSelected ? "#1e293b" : undefined;
-  const textColor = isSelected ? TUI_COLORS.text.primary : TUI_COLORS.text.muted;
   const label = shortSessionLabel(session.sessionName, projectName);
 
   return (
-    <box flexDirection="row" gap={1} paddingLeft={2} paddingRight={1} backgroundColor={bgColor}>
+    <box flexDirection="row" gap={1} paddingLeft={2} paddingRight={1}>
       <text fg={color}>{icon}</text>
-      <text fg={textColor} wrapMode="none" flexShrink={1}>
+      <text fg={TUI_COLORS.text.muted} wrapMode="none" flexShrink={1}>
         {label}
       </text>
     </box>

package/src/lib/tui/sessions/sidebar/SessionSidebar.tsx

@@ -4,13 +4,13 @@ import { SessionGroup } from "./SessionGroup";
 
 interface SessionSidebarProps {
   groups: SessionGroupData[];
-  selectedSessionId: string | null;
+  selectedGroupPath: string | null;
   focused?: boolean;
 }
 
 export function SessionSidebar({
   groups,
-  selectedSessionId,
+  selectedGroupPath,
   focused = false,
 }: SessionSidebarProps) {
   const borderColor = focused ? TUI_COLORS.ui.borderFocused : TUI_COLORS.ui.border;
@@ -38,7 +38,8 @@ export function SessionSidebar({
           <SessionGroup
             key={group.projectPath}
             group={group}
-            selectedSessionId={selectedSessionId}
+            isSelected={group.projectPath === selectedGroupPath}
+            sidebarFocused={focused}
           />
         ))
       )}

package/src/lib/tui/shared/types.ts

@@ -1,5 +1,15 @@
+import type { stopActiveSession } from "@/lib/stop-session";
+import type { DashboardOverlays } from "@/lib/tui/dashboard/DashboardOverlays";
+import type { useWorkspaceState } from "@/lib/tui/workspace/use-workspace-state";
+
 export interface DashboardProps {
   projectPath: string;
   branch?: string;
   refreshInterval?: number;
+  deps?: {
+    useWorkspaceState?: typeof useWorkspaceState;
+    DashboardOverlays?: typeof DashboardOverlays;
+    spawn?: typeof Bun.spawn;
+    stopActiveSession?: typeof stopActiveSession;
+  };
 }

package/src/lib/tui/workspace/Workspace.tsx

@@ -7,7 +7,7 @@ import type { FocusedPane, SessionGroupData } from "./workspace-types";
 
 interface WorkspaceProps extends DetailPaneProps {
   sessionGroups: SessionGroupData[];
-  selectedSessionId: string | null;
+  selectedGroupPath: string | null;
   outputVisible: boolean;
   focusedPane: FocusedPane;
   overlayBlocked?: boolean;
@@ -15,7 +15,7 @@ interface WorkspaceProps extends DetailPaneProps {
 
 export function Workspace({
   sessionGroups,
-  selectedSessionId,
+  selectedGroupPath,
   outputVisible,
   focusedPane,
   overlayBlocked = false,
@@ -31,7 +31,7 @@ export function Workspace({
       <box flexDirection="row" flexGrow={1} minHeight={0} gap={1} paddingLeft={1} paddingRight={1}>
         <SessionSidebar
           groups={sessionGroups}
-          selectedSessionId={selectedSessionId}
+          selectedGroupPath={selectedGroupPath}
           focused={sidebarFocused}
         />
         <DetailPane {...detailPaneProps} focused={detailFocused} />

package/src/lib/tui/workspace/use-workspace-state.ts

@@ -85,7 +85,7 @@ export function createInitialWorkspaceState(
     sessionGroups: [],
     allSessions: [],
     projectSessions: [],
-    selectedSessionId: null,
+    selectedGroupPath: null,
     currentSession: null,
     logEntries: [],
     fixes: [],
@@ -121,6 +121,36 @@ export function createInitialWorkspaceState(
   };
 }
 
+function buildDetailResetState(selectedGroupPath: string): Partial<WorkspaceState> {
+  const initial = createInitialWorkspaceState();
+  return {
+    currentSession: initial.currentSession,
+    logEntries: initial.logEntries,
+    fixes: initial.fixes,
+    skipped: initial.skipped,
+    findings: initial.findings,
+    storedFindings: initial.storedFindings,
+    selectedFindingIds: initial.selectedFindingIds,
+    selectedFindings: initial.selectedFindings,
+    unselectedFindings: initial.unselectedFindings,
+    fixResults: initial.fixResults,
+    unresolvedSelectedFindings: initial.unresolvedSelectedFindings,
+    auditRegressionFindings: initial.auditRegressionFindings,
+    iterationFixes: initial.iterationFixes,
+    iterationSkipped: initial.iterationSkipped,
+    iterationFindings: initial.iterationFindings,
+    latestReviewIteration: initial.latestReviewIteration,
+    codexReviewText: initial.codexReviewText,
+    tmuxOutput: initial.tmuxOutput,
+    elapsed: initial.elapsed,
+    lastSessionStats: initial.lastSessionStats,
+    projectStats: initial.projectStats,
+    currentAgent: initial.currentAgent,
+    reviewOptions: initial.reviewOptions,
+    selectedGroupPath,
+  };
+}
+
 function buildSessionGroups(
   allSessions: ActiveSession[],
   currentProjectPath: string
@@ -163,8 +193,10 @@ export function useWorkspaceState(
   projectPath: string,
   _branch?: string,
   refreshInterval: number = DEFAULT_REFRESH_INTERVAL,
-  deps: WorkspaceStateDeps = defaultWorkspaceStateDeps
+  deps: WorkspaceStateDeps = defaultWorkspaceStateDeps,
+  selectedGroupPath?: string
 ): WorkspaceState {
+  const detailPath = selectedGroupPath ?? projectPath;
   const [state, setState] = useState<WorkspaceState>(() => createInitialWorkspaceState());
 
   const stateRef = useRef(state);
@@ -179,6 +211,23 @@ export function useWorkspaceState(
   const lastLiveMetaRef = useRef<LiveRefreshMeta | null>(null);
   const logIncrementalStateRef = useRef<LogIncrementalState | undefined>(undefined);
   const lastLogSessionPathRef = useRef<string | null>(null);
+  const lastDetailPathRef = useRef<string>(detailPath);
+
+  const detailPathChanged = lastDetailPathRef.current !== detailPath;
+  if (detailPathChanged) {
+    lastDetailPathRef.current = detailPath;
+    logIncrementalStateRef.current = undefined;
+    lastLogSessionPathRef.current = null;
+    lastTmuxOutputRef.current = "";
+    lastTmuxSessionRef.current = null;
+    lastTmuxCaptureRef.current = 0;
+    tmuxCaptureIntervalRef.current = deps.tmuxCaptureMinIntervalMs;
+    lastLiveMetaRef.current = null;
+    setState((prev) => ({
+      ...prev,
+      ...buildDetailResetState(detailPath),
+    }));
+  }
 
   const refreshHeavy = useCallback(async () => {
     if (isHeavyRefreshingRef.current) return;
@@ -190,19 +239,17 @@ export function useWorkspaceState(
           deps.ensureGitRepositoryAsync(projectPath),
           deps.listAllActiveSessions(),
           deps.listProjectActiveSessions(undefined, projectPath),
-          deps.getLatestProjectActiveSession(undefined, projectPath),
-          deps.getLatestProjectLogSession(undefined, projectPath),
+          deps.getLatestProjectActiveSession(undefined, detailPath),
+          deps.getLatestProjectLogSession(undefined, detailPath),
           loadWorkspaceConfigSafe(projectPath, deps.loadEffectiveConfig),
         ]);
 
       const sessionGroups = buildSessionGroups(allSessions, projectPath);
 
-      // Auto-select: prefer current selection if still alive, then latest project session
-      const prevSelectedId = stateRef.current.selectedSessionId;
-      const stillAlive = allSessions.find((s) => s.sessionId === prevSelectedId);
-      const selectedSessionId = stillAlive
-        ? prevSelectedId
-        : (currentSession?.sessionId ?? allSessions[0]?.sessionId ?? null);
+      const selectedGroupExists = sessionGroups.some((group) => group.projectPath === detailPath);
+      const resolvedSelectedGroupPath = selectedGroupExists
+        ? detailPath
+        : (sessionGroups[0]?.projectPath ?? projectPath);
 
       let logEntries = stateRef.current.logEntries;
       let nextLogIncrementalState = logIncrementalStateRef.current;
@@ -251,12 +298,12 @@ export function useWorkspaceState(
       let projectStats: ProjectStats | null = null;
 
       if (!currentSession) {
-        const projectLogSessions = await deps.listProjectLogSessions(undefined, projectPath);
+        const projectLogSessions = await deps.listProjectLogSessions(undefined, detailPath);
         const latestSession = projectLogSessions[0];
         if (latestSession) {
           lastSessionStats = await deps.computeSessionStats(latestSession);
           projectStats = await deps.computeProjectStats(
-            deps.getProjectName(projectPath),
+            deps.getProjectName(detailPath),
             projectLogSessions
           );
         }
@@ -270,7 +317,7 @@ export function useWorkspaceState(
           sessionGroups,
           allSessions,
           projectSessions,
-          selectedSessionId,
+          selectedGroupPath: resolvedSelectedGroupPath,
           currentSession,
           logEntries,
           fixes,
@@ -306,14 +353,14 @@ export function useWorkspaceState(
     } finally {
       isHeavyRefreshingRef.current = false;
     }
-  }, [deps, projectPath]);
+  }, [deps, projectPath, detailPath]);
 
   const refreshLive = useCallback(async () => {
     if (isLiveRefreshingRef.current) return;
     isLiveRefreshingRef.current = true;
 
     try {
-      const currentSession = await deps.getLatestProjectActiveSession(undefined, projectPath);
+      const currentSession = await deps.getLatestProjectActiveSession(undefined, detailPath);
 
       let tmuxOutput = lastTmuxOutputRef.current;
       const liveMeta = getLiveRefreshMeta(currentSession);
@@ -374,7 +421,7 @@ export function useWorkspaceState(
     } finally {
       isLiveRefreshingRef.current = false;
     }
-  }, [deps, projectPath]);
+  }, [deps, detailPath]);
 
   useEffect(() => {
     void refreshHeavy();

package/src/lib/tui/workspace/workspace-types.ts

@@ -30,7 +30,7 @@ export interface WorkspaceState {
   sessionGroups: SessionGroupData[];
   allSessions: ActiveSession[];
   projectSessions: ActiveSession[];
-  selectedSessionId: string | null;
+  selectedGroupPath: string | null;
   currentSession: SessionState | null;
   logEntries: LogEntry[];
   fixes: FixEntry[];