feat(cli): resume without sessionId opens tui session picker

Make `resume` work without `<sessionId>` by opening the TUI directly on the session manager screen, using a `LaunchOptions` object to pass both `sessionId` and `initialScreen`.

Changes:

1. `src/tui.tsx`

- Change `renderApp(sessionId?: string)` → `renderApp(options: LaunchOptions = {})`.
- Pass `options.sessionId` and `options.initialScreen` through to `<App>`.
- `screen.setClearHandler` rerender: pass `{ sessionId: nextSessionId ?? options.sessionId }` (drop `initialScreen` on rerender — resets to chat).

2. `src/components/App/App.tsx`

- Change `Props` from `{ sessionId?: string }` → `{ sessionId?: string; initialScreen?: Screen }`.
- Pass `initialScreen` to `useScreenRouter`.

3. `src/components/App/hooks/useScreenRouter.ts`

- Accept `initialScreen?: Screen` param.
- Change `useState<Screen>(SCREEN.CHAT)` → `useState<Screen>(initialScreen ?? SCREEN.CHAT)`.

4. `src/cli.ts`

- Import `{ SCREEN } from './constants'` and `type { Screen } from './types'`.
- Define `interface LaunchOptions { sessionId?: string; initialScreen?: Screen }`.
- Change `'resume <sessionId>'` → `'resume [sessionId]'` (optional arg).
- Update action: if `sessionId` provided, load + validate as today; if absent, `launchTui({ initialScreen: SCREEN.SESSION_MANAGER })`.
- Change `launchTui(sessionId?: string)` → `launchTui(options: LaunchOptions = {})`, pass `options` to `renderApp`.

5. Tests

**`src/cli.test.ts`**

- Update `ResumeAction` type: `(sessionId?: string) => Promise<void>`.
- Update existing `renderApp` call assertions: `renderApp('session-1')` → `renderApp({ sessionId: 'session-1' })`.
- Update no-args TUI test: `renderApp(undefined)` → `renderApp({})`.
- Add: `resume` with no `sessionId` → `renderApp({ initialScreen: SCREEN.SESSION_MANAGER })`, no `loadSession` call.

**`src/tui.test.tsx`**

- Update `renderApp()` call → `renderApp({})` (or keep no-arg if default param is used).
- Verify `App` receives correct props for both `sessionId` and `initialScreen` paths.

**`src/components/App/hooks/useScreenRouter.test.ts`** _(if it exists)_

- Add a test for `initialScreen: SCREEN.SESSION_MANAGER` starting on that screen.

Author: remarkablemark

src/cli.test.ts

@@ -1,7 +1,7 @@
 import type { ToolResult } from './types';
 
 type RunAction = (model: string, prompt: string) => Promise<void>;
-type ResumeAction = (sessionId: string) => Promise<void>;
+type ResumeAction = (sessionId?: string) => Promise<void>;
 
 const {
   color,
@@ -105,7 +105,7 @@ describe('cli', () => {
   it('renders TUI with no args', async () => {
     await main([]);
     expect(mockReset).toHaveBeenCalledOnce();
-    expect(renderApp).toHaveBeenCalledWith(undefined);
+    expect(renderApp).toHaveBeenCalledWith({});
     expect(parse).not.toHaveBeenCalled();
   });
 
@@ -349,6 +349,16 @@ describe('cli', () => {
     expect(process.exitCode).toBe(1);
   });
 
+  it('opens the session picker when resume is called without a sessionId', async () => {
+    await commandState.resumeAction?.();
+
+    expect(loadSession).not.toHaveBeenCalled();
+    expect(mockReset).toHaveBeenCalledOnce();
+    expect(renderApp).toHaveBeenCalledWith({
+      initialScreen: 'session-manager',
+    });
+  });
+
   it('loads the requested session and renders the TUI for resume', async () => {
     loadSession.mockReturnValueOnce({
       metadata: { id: 'session-1', directory: process.cwd() },
@@ -359,7 +369,7 @@ describe('cli', () => {
 
     expect(loadSession).toHaveBeenCalledWith('session-1');
     expect(mockReset).toHaveBeenCalledOnce();
-    expect(renderApp).toHaveBeenCalledWith('session-1');
+    expect(renderApp).toHaveBeenCalledWith({ sessionId: 'session-1' });
   });
 
   it('allows resume when session has no directory field (legacy session)', async () => {
@@ -370,7 +380,7 @@ describe('cli', () => {
 
     await commandState.resumeAction?.('session-1');
 
-    expect(renderApp).toHaveBeenCalledWith('session-1');
+    expect(renderApp).toHaveBeenCalledWith({ sessionId: 'session-1' });
     expect(writeError).not.toHaveBeenCalled();
   });
 

src/cli.ts

@@ -4,9 +4,15 @@ import { realpathSync } from 'node:fs';
 
 import cac from 'cac';
 
-import { PACKAGE, ROLE, UI } from './constants';
+import { PACKAGE, ROLE, SCREEN, UI } from './constants';
+import type { Screen } from './types';
 import { agents, ollama, screen, session, terminal, tools } from './utils';
 
+interface LaunchOptions {
+  sessionId?: string;
+  initialScreen?: Screen;
+}
+
 const cli = cac('code-ollama');
 const MAX_TOOL_TURNS = 25;
 const MAX_TOOL_INTENT_CORRECTIONS = 2;
@@ -28,10 +34,16 @@ cli
   });
 
 cli
-  .command('resume <sessionId>', 'Resume a saved session')
-  .action(async (sessionId: string) => {
+  .command('resume [sessionId]', 'Resume a saved session')
+  .action(async (sessionId?: string) => {
     try {
+      if (!sessionId) {
+        await launchTui({ initialScreen: SCREEN.SESSION_MANAGER });
+        return;
+      }
+
       const loaded = session.loadSession(sessionId);
+
       if (
         loaded.metadata.directory &&
         loaded.metadata.directory !== process.cwd()
@@ -45,7 +57,8 @@ cli
         process.exitCode = 1;
         return;
       }
-      await launchTui(sessionId);
+
+      await launchTui({ sessionId });
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Unknown error';
       terminal.writeError(`Error: ${message}\n`);
@@ -164,10 +177,10 @@ export async function main(
   }
 }
 
-async function launchTui(sessionId?: string): Promise<void> {
+async function launchTui(options: LaunchOptions = {}): Promise<void> {
   const { renderApp } = await import('./tui');
   screen.reset();
-  renderApp(sessionId);
+  renderApp(options);
 }
 
 // v8 ignore start

src/components/App/App.tsx

@@ -10,17 +10,18 @@ import { SessionManager } from '@/components/SessionManager';
 import { ThemeSettings } from '@/components/ThemeSettings';
 import { UpdateBanner } from '@/components/UpdateBanner';
 import { MODE, SCREEN, THEME } from '@/constants';
-import type { Config, Mode } from '@/types';
+import type { Config, Mode, Screen } from '@/types';
 import { config, ollama, session } from '@/utils';
 
 import { useScreenRouter, useSessionManager, useThemeSettings } from './hooks';
 import { ReadinessCheck, ReadinessState } from './ReadinessCheck';
 
 interface Props {
   sessionId?: string;
+  initialScreen?: Screen;
 }
 
-export function App({ sessionId }: Props) {
+export function App({ sessionId, initialScreen }: Props) {
   const [appConfig, setConfig] = useState(() => config.loadConfig());
   const [mode, setMode] = useState<Mode>(MODE.SAFE);
   const [isLoaded, setIsLoaded] = useState(false);
@@ -32,7 +33,7 @@ export function App({ sessionId }: Props) {
   );
 
   const { currentScreen, setScreen, handleClose, handleCommand } =
-    useScreenRouter();
+    useScreenRouter({ initialScreen });
 
   const {
     activeSession,

src/components/App/hooks/useScreenRouter.ts

@@ -12,9 +12,17 @@ export interface CommandCallbacks {
   onSetPreviewThemeId: (themeId: ThemeId) => void;
 }
 
-export function useScreenRouter() {
+interface UseScreenRouterOptions {
+  initialScreen?: Screen;
+}
+
+export function useScreenRouter({
+  initialScreen,
+}: UseScreenRouterOptions = {}) {
   const { exit } = useApp();
-  const [currentScreen, setScreen] = useState<Screen>(SCREEN.CHAT);
+  const [currentScreen, setScreen] = useState<Screen>(
+    initialScreen ?? SCREEN.CHAT,
+  );
 
   const handleClose = useCallback(() => {
     setScreen(SCREEN.CHAT);

src/tui.tsx

@@ -1,20 +1,33 @@
 import { render } from 'ink';
 
 import { App } from './components';
+import type { Screen } from './types';
 import { screen } from './utils';
 
-export function renderApp(sessionId?: string): void {
+export interface LaunchOptions {
+  sessionId?: string;
+  initialScreen?: Screen;
+}
+
+export function renderApp(options: LaunchOptions = {}): void {
   let resetKey = 0;
 
-  const app = render(<App key={resetKey} sessionId={sessionId} />, {
-    exitOnCtrlC: false,
-    maxFps: 60,
-  });
+  const app = render(
+    <App
+      key={resetKey}
+      sessionId={options.sessionId}
+      initialScreen={options.initialScreen}
+    />,
+    {
+      exitOnCtrlC: false,
+      maxFps: 60,
+    },
+  );
 
   screen.setClearHandler((nextSessionId) => {
     screen.reset();
     app.rerender(
-      <App key={++resetKey} sessionId={nextSessionId ?? sessionId} />,
+      <App key={++resetKey} sessionId={nextSessionId ?? options.sessionId} />,
     );
   });
 }