@thegitai/cli 1.0.0-beta.19 → 1.0.0-beta.20

package/README.md

@@ -26,6 +26,23 @@ ai --version        print the version and exit
 
 Run `ai --help` for sessions, modes, keys, and chat commands.
 
+## Visible to-do list
+
+For larger multi-step tasks, the agent keeps a compact to-do list on screen so
+you can see what it plans to do, what it is working on right now, and what is
+already done.
+
+- While the agent works, the list sits at the bottom of the live **Working**
+  area, right above where you type, and updates as steps start and finish —
+  one step in progress at a time — so it stays visible even when tool output
+  above it runs long.
+- When the turn ends, a final snapshot of the list stays readable in the
+  transcript, and the footer shows a small progress chip (e.g. `◐ 4/6 to-dos`)
+  while steps remain open.
+- The agent's current reasoning stays visible too, right below the list, in a
+  compact one-line form so it doesn't compete with the list for space.
+- The list is managed entirely by the agent; simple one-step requests skip it.
+
 ## Background jobs
 
 Some commands are meant to keep running — a dev server, a file watcher, a local

package/dist/src/agent-mode.js

@@ -13,6 +13,7 @@ const PLAN_MODE_TOOL_NAMES = new Set([
     'analyze_image',
     'run_command',
     'shell_job_output',
+    'update_todos',
 ]);
 const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
     'pwd',

package/dist/src/todo-list.js

@@ -0,0 +1,106 @@
+export const MAX_TODO_ITEMS = 20;
+export const MAX_TODO_TEXT_CHARS = 160;
+let items = [];
+let activeSessionId = null;
+const STATUS_ALIASES = {
+    pending: 'pending',
+    todo: 'pending',
+    not_started: 'pending',
+    in_progress: 'in_progress',
+    active: 'in_progress',
+    doing: 'in_progress',
+    completed: 'completed',
+    complete: 'completed',
+    done: 'completed',
+};
+function normalizeStatus(raw) {
+    const key = String(raw ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/g, '_');
+    return STATUS_ALIASES[key] ?? null;
+}
+export function isCompletedStatus(raw) {
+    return normalizeStatus(raw) === 'completed';
+}
+const TODOS_ARG_ALIASES = ['items', 'todo_list', 'todoList', 'list', 'tasks'];
+export function extractTodosArg(args) {
+    if (!args || typeof args !== 'object')
+        return undefined;
+    const record = args;
+    if (record.todos !== undefined)
+        return record.todos;
+    for (const key of TODOS_ARG_ALIASES) {
+        if (record[key] !== undefined)
+            return record[key];
+    }
+    return undefined;
+}
+export function setTodoSession(sessionId) {
+    const next = String(sessionId ?? '').trim() || null;
+    if (activeSessionId !== next) {
+        items = [];
+    }
+    activeSessionId = next;
+}
+export function listTodos() {
+    return items.map((item) => ({ ...item }));
+}
+export function getTodoSnapshot() {
+    return {
+        items: listTodos(),
+        completedCount: items.filter((item) => item.status === 'completed').length,
+        totalCount: items.length,
+    };
+}
+export function clearTodos() {
+    items = [];
+}
+export function replaceTodos(raw) {
+    if (!Array.isArray(raw)) {
+        return { ok: false, error: 'todos must be an array of { text, status } items.' };
+    }
+    const normalizations = [];
+    if (raw.length > MAX_TODO_ITEMS) {
+        return {
+            ok: false,
+            error: `todos supports at most ${MAX_TODO_ITEMS} items; got ${raw.length}. Use fewer, broader steps.`,
+        };
+    }
+    const next = [];
+    let sawInProgress = false;
+    for (const [index, entry] of raw.entries()) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return { ok: false, error: `todos[${index}] must be an object with text and status.` };
+        }
+        const text = String(entry.text ?? '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!text) {
+            return { ok: false, error: `todos[${index}].text must be a non-empty string.` };
+        }
+        const status = normalizeStatus(entry.status);
+        if (!status) {
+            return {
+                ok: false,
+                error: `todos[${index}].status must be one of: pending, in_progress, completed.`,
+            };
+        }
+        let boundedText = text;
+        if (boundedText.length > MAX_TODO_TEXT_CHARS) {
+            boundedText = `${boundedText.slice(0, MAX_TODO_TEXT_CHARS - 1)}…`;
+            normalizations.push(`todos[${index}].text truncated to ${MAX_TODO_TEXT_CHARS} chars`);
+        }
+        let finalStatus = status;
+        if (status === 'in_progress') {
+            if (sawInProgress) {
+                finalStatus = 'pending';
+                normalizations.push(`todos[${index}] demoted to pending: only one item can be in_progress`);
+            }
+            sawInProgress = true;
+        }
+        next.push({ text: boundedText, status: finalStatus });
+    }
+    items = next;
+    return { ok: true, snapshot: getTodoSnapshot(), normalizations };
+}

package/dist/src/tool-executor.js

@@ -6,6 +6,7 @@ import { dispatchTool } from './tools/index.js';
 import { syncIndexFromDisk } from './project-index.js';
 import { PATH_REPAIRING_EDIT_TOOLS, repairFilePath } from './tools/path-suggest.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './tools/shell-diagnostics.js';
+import { extractTodosArg } from './todo-list.js';
 const EDIT_FILE_PATH_ARG_ALIASES = [
     'filePath',
     'file_path',
@@ -27,6 +28,13 @@ function toolCallSummary(call) {
         call.name === 'shell_job_kill') {
         return String(args.job_id ?? '').trim();
     }
+    if (call.name === 'update_todos') {
+        const raw = extractTodosArg(args);
+        const todos = Array.isArray(raw) ? raw : [];
+        if (todos.length === 0)
+            return '';
+        return `${todos.length} item${todos.length === 1 ? '' : 's'}`;
+    }
     const filePath = getEditToolFilePath(call);
     if (filePath)
         return filePath;

package/dist/src/tools/index.js

@@ -21,6 +21,7 @@ import { getSignatureHelp } from './signature-help.js';
 import { shellJobKill } from './shell-job-kill.js';
 import { strReplace } from './str-replace.js';
 import { undoEdit } from './undo-edit.js';
+import { updateTodos } from './update-todos.js';
 import { writeFile } from './write-file.js';
 export const TOOL_MAP = {
     search_code: (context, args) => searchCode(context.projectIndex, args),
@@ -48,6 +49,7 @@ export const TOOL_MAP = {
     run_node_script: runNodeScript,
     shell_job_output: shellJobOutput,
     shell_job_kill: shellJobKill,
+    update_todos: updateTodos,
 };
 function invalidToolCall(error) {
     return {

package/dist/src/tools/update-todos.js

@@ -0,0 +1,27 @@
+import { extractTodosArg, replaceTodos } from '../todo-list.js';
+export function updateTodos(_context, args) {
+    const rawTodos = extractTodosArg(args);
+    if (rawTodos === undefined) {
+        return {
+            ok: false,
+            error: 'todos is required (pass [] to clear the list).',
+            failureCategory: 'missing_required_argument',
+        };
+    }
+    const result = replaceTodos(rawTodos);
+    if (!result.ok) {
+        return {
+            ok: false,
+            error: result.error,
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const { snapshot, normalizations } = result;
+    return {
+        ok: true,
+        todos: snapshot.items,
+        completedCount: snapshot.completedCount,
+        totalCount: snapshot.totalCount,
+        ...(normalizations.length ? { normalizations } : {}),
+    };
+}

package/dist/src/ui/repl.js

@@ -1,10 +1,11 @@
 import { createRatatuiBridge } from './tui/bridge.js';
-import { buildTuiFrame, formatJobElapsed, renderTranscriptEntryLines, } from './tui/build-frame.js';
+import { buildTuiFrame, formatJobElapsed, formatTodoProgress, renderTranscriptEntryLines, } from './tui/build-frame.js';
 export { getSlashCommandSuggestions } from './tui/build-frame.js';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
 import { isTurnCancelledError } from '../api/chat.js';
 import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, killAllBackgroundJobs, killBackgroundJob, listBackgroundJobs, setBackgroundJobSession, setBackgroundJobUpdateHook, } from '../background-jobs.js';
+import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { cancelActiveCommand } from '../executor.js';
 import { setCommandOutputHook, withTuiMode } from '../runtime-mode.js';
 import { collectBackgroundJobUiKillMutations, collectBackgroundJobUiOutputMutations, } from '../tool-executor.js';
@@ -867,11 +868,16 @@ function createShellStore(initialState) {
         },
         appendWorkingTool: (entry) => {
             const lastEntry = state.workingTools.at(-1);
-            if (sameTranscriptDraft(lastEntry, entry))
+            const isDuplicate = sameTranscriptDraft(lastEntry, entry);
+            if (isDuplicate && state.commandLog.length === 0) {
                 return;
+            }
             state = {
                 ...state,
-                workingTools: [...state.workingTools, entry].slice(-WORKING_TOOL_PREVIEW_ITEMS),
+                commandLog: [],
+                workingTools: isDuplicate
+                    ? state.workingTools
+                    : [...state.workingTools, entry].slice(-WORKING_TOOL_PREVIEW_ITEMS),
             };
             notify();
         },
@@ -956,6 +962,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         exitConfirmUntil: null,
         thinkingTitle: '',
         thinkingNotes: [],
+        todos: listTodos(),
         tokenUsage: formatClientTokenUsage(null),
         transcript: [],
         turnCounter: Math.max(0, session.history.filter((entry) => entry.role === 'user').length),
@@ -1008,6 +1015,14 @@ function thinkingNoteFromStatus(status) {
     const note = text.slice('Thinking:'.length).trim();
     return note ? note : null;
 }
+function stripMarkdownEmphasis(text) {
+    return text
+        .replace(/\*\*\*(.+?)\*\*\*/g, '$1')
+        .replace(/___(.+?)___/g, '$1')
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        .replace(/__(.+?)__/g, '$1')
+        .replace(/(?<!\*)\*(?!\*)([^*\n]+?)\*(?!\*)/g, '$1');
+}
 function splitThinkingLines(text) {
     return text
         .split('\n')
@@ -1016,13 +1031,13 @@ function splitThinkingLines(text) {
         .flatMap((line) => line
         .split(/(?<=[.!?])\s+(?=[A-Z0-9"'`])/)
         .map((part) => part.trim())
-        .filter(Boolean))
-        .map((line) => truncate(line, 120));
+        .filter(Boolean));
 }
 function thinkingPanelFromStatus(status) {
-    const text = thinkingNoteFromStatus(status);
-    if (!text)
+    const rawText = thinkingNoteFromStatus(status);
+    if (!rawText)
         return null;
+    const text = stripMarkdownEmphasis(rawText);
     const rawLines = text
         .split('\n')
         .map((line) => line.trim())
@@ -1031,12 +1046,12 @@ function thinkingPanelFromStatus(status) {
         return null;
     if (rawLines.length === 1 && rawLines[0].length <= 72) {
         return {
-            title: truncate(rawLines[0], 72),
+            title: rawLines[0],
             notes: [],
         };
     }
     const title = rawLines.length > 1 && rawLines[0].length <= 72
-        ? truncate(rawLines[0], 72)
+        ? rawLines[0]
         : 'Thinking';
     const bodyLines = rawLines.length > 1 && rawLines[0].length <= 72 ? rawLines.slice(1) : rawLines;
     return {
@@ -1241,6 +1256,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
     }
     await withTuiMode(async () => {
         setBackgroundJobSession(session.sessionId);
+        setTodoSession(session.sessionId);
         const store = createShellStore(createInitialShellState(session, serverModels, debugUi));
         store.replaceTranscript(createSessionTranscript(session));
         let currentServerModels = serverModels;
@@ -1263,6 +1279,10 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let latestUsageSummary = null;
         let pendingTurnEntries = [];
         let activeTurnAbort = null;
+        let todosTouchedThisTurn = false;
+        const syncTodosState = () => {
+            store.update((current) => ({ ...current, todos: listTodos() }));
+        };
         let activeTurnGeneration = 0;
         let exitCtrlCArmed = false;
         let exitCtrlCTimer = null;
@@ -1904,6 +1924,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 applySessionSnapshot(session, snapshot);
                 setBackgroundJobSession(session.sessionId);
                 syncBackgroundJobsState();
+                setTodoSession(session.sessionId);
+                syncTodosState();
                 await saveActiveSession();
                 syncShellStateFromSession();
                 store.update((next) => ({
@@ -2140,6 +2162,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             }
             if (input === '/clear') {
                 clearConversation(session);
+                clearTodos();
+                syncTodosState();
                 latestUsageSummary = null;
                 await saveActiveSession();
                 store.replaceTranscript([
@@ -2161,6 +2185,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             const turnAbort = new AbortController();
             activeTurnAbort = turnAbort;
             lastTurnStartedAt = turnStartedAt;
+            todosTouchedThisTurn = false;
             const userEntry = {
                 body: input,
                 kind: 'user',
@@ -2215,6 +2240,22 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 await appendSettledTurnEntries(turnEntries, result.text ?? '', () => turnGeneration === activeTurnGeneration && !turnAbort.signal.aborted);
                 if (turnGeneration !== activeTurnGeneration)
                     return;
+                if (todosTouchedThisTurn) {
+                    todosTouchedThisTurn = false;
+                    const todoItems = listTodos();
+                    if (todoItems.length > 0) {
+                        appendStaticEntry({
+                            body: '',
+                            kind: 'system',
+                            title: `To-dos · ${formatTodoProgress(todoItems)}`,
+                            todoList: todoItems,
+                        });
+                        if (todoItems.every((item) => item.status === 'completed')) {
+                            clearTodos();
+                            syncTodosState();
+                        }
+                    }
+                }
                 store.update((current) => ({
                     ...current,
                     busy: false,
@@ -2295,6 +2336,13 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         };
         session.onToolEvent = (event) => {
             syncShellStateFromSession();
+            if (event.call.name === 'update_todos') {
+                syncTodosState();
+                if (event.result?.ok === true) {
+                    todosTouchedThisTurn = true;
+                    return;
+                }
+            }
             if (isFileChangeTool(event.call.name)) {
                 const entry = buildFileChangeEntry(event);
                 store.appendWorkingTool(entry);
@@ -2472,6 +2520,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             clearLiveFrameRemountTimer();
             killAllBackgroundJobs();
             setBackgroundJobSession(null);
+            setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
             setCommandOutputHook(null);

package/dist/src/ui/tui/build-frame.js

@@ -5,6 +5,8 @@ import { renderFormattedBodyLines, renderPreformattedBodyLines, } from './markdo
 import { line, plainLine, span, wrapText } from './text.js';
 const WORKING_CLOCK_ICON = '◷';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
+const TODO_PANEL_MAX_ROWS = 12;
+const TODO_IN_PROGRESS_COLOR = 'ansi256(214)';
 const COMMAND_PREVIEW_LINES = 10;
 const WORKING_TOOL_PREVIEW_ROWS = 3;
 const TRANSCRIPT_DIFF_PREVIEW_LINES = 24;
@@ -131,7 +133,7 @@ function diffLinePrefix(kind) {
             return ' ';
     }
 }
-function fitDiffLine(content, maxWidth) {
+function fitLine(content, maxWidth) {
     if (maxWidth <= 0)
         return '';
     if (content.length <= maxWidth)
@@ -230,6 +232,55 @@ function formatRelativeTime(isoDate) {
         return `${hours}h ago`;
     return `${Math.floor(hours / 24)}d ago`;
 }
+function todoItemLine(item, width) {
+    const text = fitLine(item.text, Math.max(8, width - 5));
+    if (item.status === 'completed') {
+        return line(span('  ✔ ', { color: 'green' }), span(text, { color: 'gray', dim: true }));
+    }
+    if (item.status === 'in_progress') {
+        return line(span('  ◐ ', { color: TODO_IN_PROGRESS_COLOR }), span(text, { color: TODO_IN_PROGRESS_COLOR, bold: true }));
+    }
+    return line(span('  ○ ', { color: 'gray' }), span(text));
+}
+export function formatTodoProgress(items) {
+    const done = items.filter((item) => item.status === 'completed').length;
+    return `${done}/${items.length} done`;
+}
+export function renderTodoListLines(items, width, { header = false } = {}) {
+    if (items.length === 0)
+        return [];
+    const lines = [];
+    if (header) {
+        lines.push(line(span('To-dos', { color: 'cyan', bold: true }), span(` · ${formatTodoProgress(items)}`, { color: 'gray' })));
+    }
+    const itemRowBudget = TODO_PANEL_MAX_ROWS - (header ? 1 : 0);
+    let collapsedDone = 0;
+    if (items.length > itemRowBudget) {
+        const over = items.length - (itemRowBudget - 1);
+        let leadingDone = 0;
+        while (leadingDone < items.length &&
+            items[leadingDone].status === 'completed') {
+            leadingDone += 1;
+        }
+        collapsedDone = Math.min(over, leadingDone);
+    }
+    if (collapsedDone > 0) {
+        lines.push(line(span('  ✔ ', { color: 'green' }), span(`${collapsedDone} completed`, { color: 'gray', dim: true })));
+    }
+    const remaining = items.slice(collapsedDone);
+    const budget = itemRowBudget - (collapsedDone > 0 ? 1 : 0);
+    const visible = remaining.length > budget ? remaining.slice(0, budget - 1) : remaining;
+    for (const item of visible) {
+        lines.push(todoItemLine(item, width));
+    }
+    if (remaining.length > visible.length) {
+        lines.push(plainLine(`  … +${remaining.length - visible.length} more`, {
+            color: 'gray',
+            dim: true,
+        }));
+    }
+    return lines;
+}
 export function renderTranscriptEntryLines(entry, width) {
     const color = getEntryColor(entry.kind);
     const lines = [
@@ -241,11 +292,14 @@ export function renderTranscriptEntryLines(entry, width) {
     if (entry.diffPreview) {
         lines.push(plainLine(`  Added ${entry.diffPreview.added} line${entry.diffPreview.added === 1 ? '' : 's'}, removed ${entry.diffPreview.removed} line${entry.diffPreview.removed === 1 ? '' : 's'}`, { color: 'gray' }));
         for (const diffLine of entry.diffPreview.lines.slice(0, TRANSCRIPT_DIFF_PREVIEW_LINES)) {
-            lines.push(line(span(`${diffLinePrefix(diffLine.kind)} `, { color: diffLineColor(diffLine.kind) }), span(fitDiffLine(diffLine.content || ' ', width - 4), {
+            lines.push(line(span(`${diffLinePrefix(diffLine.kind)} `, { color: diffLineColor(diffLine.kind) }), span(fitLine(diffLine.content || ' ', width - 4), {
                 color: diffLineColor(diffLine.kind),
             })));
         }
     }
+    if (entry.todoList && entry.todoList.length > 0) {
+        lines.push(...renderTodoListLines(entry.todoList, width));
+    }
     return lines;
 }
 function tokenUsageLines(usage) {
@@ -298,6 +352,23 @@ function backgroundJobIndicatorSpans(state) {
         span(' · /jobs', { color: 'gray', dim: true }),
     ];
 }
+function todoIndicatorSpans(state) {
+    if (state.busy)
+        return [];
+    const items = state.todos ?? [];
+    if (items.length === 0)
+        return [];
+    const done = items.filter((item) => item.status === 'completed').length;
+    if (done >= items.length)
+        return [];
+    return [
+        span('   ', { color: 'gray', dim: true }),
+        span(`◐ ${done}/${items.length} to-dos`, {
+            color: TODO_IN_PROGRESS_COLOR,
+            bold: true,
+        }),
+    ];
+}
 function composerFooterLines(state) {
     const visibleSessionId = formatPromptSessionIdLabel(state.showSessionId, state.sessionId);
     const transientStatus = footerTransientStatus(state.status);
@@ -316,7 +387,7 @@ function composerFooterLines(state) {
             ]
             : []), ...(visibleSessionId
             ? [span(`   ${visibleSessionId}`, { color: 'gray', dim: true })]
-            : []), ...backgroundJobIndicatorSpans(state)),
+            : []), ...backgroundJobIndicatorSpans(state), ...todoIndicatorSpans(state)),
         plainLine(''),
         plainLine(formatModelLabel(state.currentModelId, state.serverModels), {
             color: 'cyan',
@@ -432,6 +503,16 @@ function buildJobsPickerLines(state, width, nowMs) {
     }));
     return lines;
 }
+function thinkingHeaderLine(spinnerFrame, title, width) {
+    const spinner = `${BRAILLE_SPINNER_FRAMES[spinnerFrame % BRAILLE_SPINNER_FRAMES.length]} `;
+    const fittedTitle = title
+        ? fitLine(title, Math.max(8, width - spinner.length - 'Thinking'.length - 3))
+        : '';
+    return line(span(spinner, { color: 'green' }), span('Thinking', { color: 'green', bold: true }), ...(fittedTitle ? [span(` · ${fittedTitle}`, { color: 'ansi256(248)' })] : []));
+}
+function thinkingNoteLine(note, width) {
+    return line(span('│  ', { color: 'green' }), span(fitLine(note, Math.max(8, width - 3)), { color: 'ansi256(248)' }));
+}
 function buildLiveLines(state, width, spinnerFrame, elapsedSeconds) {
     if (!state.busy)
         return [];
@@ -445,33 +526,44 @@ function buildLiveLines(state, width, spinnerFrame, elapsedSeconds) {
         }, width));
         lines.push(plainLine(''));
     }
-    lines.push(plainLine(`${WORKING_CLOCK_ICON} Working · ${elapsedSeconds < 60 ? `${elapsedSeconds}s` : `${Math.floor(elapsedSeconds / 60)}m ${String(elapsedSeconds % 60).padStart(2, '0')}s`}`, { color: 'yellow' }));
-    const visibleTitle = state.thinkingTitle.trim();
-    const visibleNotes = state.thinkingNotes.filter(Boolean).slice(-THINKING_NOTE_PREVIEW_ROWS);
-    if (visibleTitle || visibleNotes.length > 0) {
-        lines.push(plainLine(''));
-        lines.push(line(span(`${BRAILLE_SPINNER_FRAMES[spinnerFrame % BRAILLE_SPINNER_FRAMES.length]} `, {
-            color: 'green',
-        }), span('Thinking', { color: 'green', bold: true }), ...(visibleTitle ? [span(` · ${visibleTitle}`, { color: 'ansi256(248)' })] : [])));
-        for (const note of visibleNotes) {
-            lines.push(line(span('│  ', { color: 'green' }), span(note, { color: 'ansi256(248)' })));
-        }
-    }
     const toolEntries = state.workingTools.slice(-WORKING_TOOL_PREVIEW_ROWS);
     if (toolEntries.length > 0) {
-        lines.push(plainLine(''));
         for (const entry of toolEntries) {
             const color = getEntryColor(entry.kind);
             const body = entry.body.split('\n')[0]?.trim();
             lines.push(line(span('● ', { color }), span(entry.title, { color, bold: true }), ...(body ? [span(` ${truncate(body, 140)}`, { color })] : [])));
         }
+        lines.push(plainLine(''));
     }
     const logLines = state.commandLog.slice(-COMMAND_PREVIEW_LINES);
     if (logLines.length > 0) {
-        lines.push(plainLine(''));
+        lines.push(plainLine('⋮ output', { color: 'gray', dim: true }));
         for (const outputLine of logLines) {
             lines.push(plainLine(outputLine, { color: 'gray', dim: true }));
         }
+        lines.push(plainLine(''));
+    }
+    lines.push(plainLine(`${WORKING_CLOCK_ICON} Working · ${elapsedSeconds < 60 ? `${elapsedSeconds}s` : `${Math.floor(elapsedSeconds / 60)}m ${String(elapsedSeconds % 60).padStart(2, '0')}s`}`, { color: 'yellow' }));
+    if (state.todos.length > 0) {
+        lines.push(plainLine(''));
+        lines.push(...renderTodoListLines(state.todos, width, { header: true }));
+    }
+    const visibleTitle = state.thinkingTitle.trim();
+    const visibleNotes = state.thinkingNotes.filter(Boolean);
+    if (visibleTitle || visibleNotes.length > 0) {
+        lines.push(plainLine(''));
+        if (state.todos.length > 0) {
+            const minimalText = visibleTitle && visibleTitle !== 'Thinking'
+                ? visibleTitle
+                : (visibleNotes[visibleNotes.length - 1] ?? '');
+            lines.push(thinkingHeaderLine(spinnerFrame, minimalText, width));
+        }
+        else {
+            lines.push(thinkingHeaderLine(spinnerFrame, visibleTitle, width));
+            for (const note of visibleNotes.slice(-THINKING_NOTE_PREVIEW_ROWS)) {
+                lines.push(thinkingNoteLine(note, width));
+            }
+        }
     }
     lines.push(plainLine(''));
     return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-beta.19",
+  "version": "1.0.0-beta.20",
   "description": "TheGitAI CLI client (source-visible, proprietary)",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://thegit.ai",
@@ -25,10 +25,10 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-beta.19",
-    "@thegitai/tui-darwin-x64": "1.0.0-beta.19",
-    "@thegitai/tui-linux-x64": "1.0.0-beta.19",
-    "@thegitai/tui-win32-x64": "1.0.0-beta.19",
+    "@thegitai/tui-darwin-arm64": "1.0.0-beta.20",
+    "@thegitai/tui-darwin-x64": "1.0.0-beta.20",
+    "@thegitai/tui-linux-x64": "1.0.0-beta.20",
+    "@thegitai/tui-win32-x64": "1.0.0-beta.20",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {