ralph-review 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-review",
-  "version": "0.2.5",
+  "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/tui/dashboard/Dashboard.tsx

@@ -11,6 +11,7 @@ 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";
@@ -21,7 +22,14 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
   const renderer = useRenderer();
   const resolvedUseWorkspaceState = deps?.useWorkspaceState ?? useWorkspaceState;
   const ResolvedDashboardOverlays = deps?.DashboardOverlays ?? DashboardOverlays;
-  const state = resolvedUseWorkspaceState(projectPath, branch, refreshInterval);
+  const [selectedGroupPath, setSelectedGroupPath] = useState<string>(projectPath);
+  const state = resolvedUseWorkspaceState(
+    projectPath,
+    branch,
+    refreshInterval,
+    undefined,
+    selectedGroupPath
+  );
   const {
     runError,
     startupMode,
@@ -85,6 +93,15 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
     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) {
@@ -124,6 +141,18 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
     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({
@@ -137,6 +166,8 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
         hasCurrentSession: Boolean(state.currentSession),
         canFixPendingSession,
         isRunSpawning: isStartupSpawning(),
+        sidebarFocused: focusedPane === "sidebar",
+        sessionGroupCount: state.sessionGroups.length,
       });
 
       switch (action) {
@@ -187,6 +218,12 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
           clearRunError();
           setShowReviewModeOverlay(true);
           return;
+        case "select-prev-group":
+          selectPrevGroup();
+          return;
+        case "select-next-group":
+          selectNextGroup();
+          return;
       }
     },
     [
@@ -194,7 +231,10 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
       clearRunError,
       cycleFocus,
       cycleFocusReverse,
+      focusedPane,
       isStartupSpawning,
+      selectNextGroup,
+      selectPrevGroup,
       showFixFindings,
       showHelp,
       showReviewModeOverlay,
@@ -203,6 +243,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
       shutdown,
       state.allSessions,
       state.currentSession,
+      state.sessionGroups.length,
       stopSelectedSession,
     ]
   );
@@ -238,7 +279,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }:
         ) : (
           <Workspace
             sessionGroups={state.sessionGroups}
-            selectedSessionId={state.selectedSessionId}
+            selectedGroupPath={selectedGroupPath}
             session={state.currentSession}
             fixes={state.fixes}
             skipped={state.skipped}

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/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/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[];