maka-agent 0.2.0-dev.23.20260906 → 0.2.0-dev.25.20260908

package/dist/pi-tui-runner.js

@@ -17,8 +17,8 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { basename } from 'node:path';
 import { Key, ProcessTerminal, SelectList, TuiMainScreen, isKeyRelease, isKeyRepeat, matchesKey, } from '@earendil-works/pi-tui';
+import { CurrentTodoStore, TodoOverlay, renderTodoIndicator } from './pi-tui-todo.js';
 import { isThinkingLevel } from '@maka/core/model-thinking';
 import { deriveConnectionSlug, } from '@maka/core/llm-connections';
 import { projectRevisionLinkedSessionTree } from '@maka/core/session-revisions';
@@ -41,6 +41,7 @@ import { MakaAutocompleteAboveEditorComponent } from './tui-autocomplete-layout.
 import { TranscriptViewerOverlay } from './pi-tui-transcript-viewer.js';
 import { copyToClipboard } from './tui-clipboard.js';
 import { getTuiCopyCopy, lastAssistantText, serializeTranscriptText } from './tui-copy-command.js';
+import { getTuiHostOwnerCopy } from './tui-host-owner-copy.js';
 import { McpManagementOverlay } from './pi-tui-mcp-status.js';
 import { createShellRunElapsedTicker } from './shell-run-elapsed-ticker.js';
 import { createShellRunHydrationController } from './shell-run-hydration.js';
@@ -48,7 +49,7 @@ import { CTX_REFRESH_DEBOUNCE_MS, createCtxRefresher, scheduleCtxRefreshTimeout,
 import { sessionStatusBadge } from './tui-session-status.js';
 import { AttentionController, DISABLE_FOCUS_REPORTING, ENABLE_FOCUS_REPORTING, FOCUS_IN_SEQUENCE, FOCUS_OUT_SEQUENCE, } from './tui-attention.js';
 import { MakaActivityStripComponent, MakaPendingQueueComponent, MakaPiLayoutComponent, MakaStatusLineComponent, MakaTranscriptComponent, } from './pi-tui-layout.js';
-import { MakaAutocompleteProvider, DirectoryPickerOverlay, ModelSearchOverlay, OnboardingWizard, PickerOverlay, UserQuestionOverlay, modelChoiceConnectionLabels, getTuiPickerCopy, modelPickerItems, onboardingFailureMessage, permissionModePickerItems, skillPickerItems, thinkingLevelPickerItems, } from './pi-tui-pickers.js';
+import { MakaAutocompleteProvider, DirectoryPickerOverlay, ModelSearchOverlay, SessionSearchOverlay, OnboardingWizard, PickerOverlay, UserQuestionOverlay, modelChoiceConnectionLabels, getTuiPickerCopy, modelPickerItems, onboardingFailureMessage, permissionModePickerItems, skillPickerItems, thinkingLevelPickerItems, } from './pi-tui-pickers.js';
 import { formatMakaResumeCommand } from './cli-invocation.js';
 import { goalAttachedNoticeText, goalPausedNoticeText, goalStatusLabel, goalSummaryLines, isLiveGoalStatus, } from './pi-goal.js';
 import { getTuiPrimaryGuidance } from './tui-primary-guidance.js';
@@ -211,6 +212,20 @@ export async function runMakaPiTui(input) {
     // True while the /session picker is open mid-turn: Escape must close the
     // overlay, not arm the double-Escape interrupt for the running Turn (#3380).
     let sessionPickerOverlayOpen = false;
+    let transcriptOverlay;
+    let todoOverlay;
+    const closeTodoOverlay = () => {
+        todoOverlay?.hide();
+        todoOverlay = undefined;
+    };
+    let transcriptViewer;
+    let transcriptViewerSessionId;
+    const resetTranscriptViewer = () => {
+        transcriptOverlay?.hide();
+        transcriptOverlay = undefined;
+        transcriptViewer = undefined;
+        transcriptViewerSessionId = undefined;
+    };
     let lastTurnEscapeAt = 0;
     let lastIdleEscapeAt = 0;
     let lastIdleCtrlCAt = 0;
@@ -317,6 +332,34 @@ export async function runMakaPiTui(input) {
     const activityStrip = new MakaActivityStripComponent(metadata);
     const pendingQueue = new MakaPendingQueueComponent(state, locale);
     const statusLine = new MakaStatusLineComponent(metadata);
+    const currentTodo = new CurrentTodoStore({
+        read: async (sessionId) => {
+            if (!input.driver.queryTodo)
+                throw new Error('Todo query unavailable');
+            return input.driver.queryTodo(sessionId);
+        },
+    }, () => {
+        if (!closed)
+            tui.requestRender();
+    });
+    const syncTodoSession = () => {
+        currentTodo.setSession(input.driver.getSessionId() ?? undefined);
+    };
+    const unsubscribeTodoChanges = input.driver.subscribeTodoChanges?.((sessionId) => {
+        if (sessionId !== input.driver.getSessionId())
+            return;
+        syncTodoSession();
+        void currentTodo.refresh();
+    });
+    const todoIndicator = {
+        invalidate() { },
+        render(width) {
+            if (!input.driver.queryTodo)
+                return [];
+            const line = renderTodoIndicator(currentTodo.getState(), { locale, width });
+            return line === undefined ? [] : [line];
+        },
+    };
     // Use the vendor editor's full 20-item autocomplete capacity. Larger command
     // catalogs remain scrollable and keep an exact position/total counter.
     const editor = new MakaSkillHighlightEditor(tui, editorTheme(), {
@@ -325,7 +368,7 @@ export async function runMakaPiTui(input) {
     });
     let refreshEditorCwd;
     const editorSurface = new MakaAutocompleteAboveEditorComponent(editor);
-    const layout = new MakaPiLayoutComponent(state, transcript, activityStrip, pendingQueue, editorSurface, statusLine, terminal);
+    const layout = new MakaPiLayoutComponent(state, transcript, activityStrip, pendingQueue, editorSurface, statusLine, terminal, todoIndicator);
     const attention = new AttentionController(terminal, {
         baseTitle: input.title,
         ...(input.attentionLongTurnThresholdMs !== undefined
@@ -607,6 +650,9 @@ export async function runMakaPiTui(input) {
         unsubscribeModelCatalogChanges?.();
         unsubscribeSessionTitleChanges();
         unsubscribeGoalChanges?.();
+        unsubscribeTodoChanges?.();
+        currentTodo.dispose();
+        closeTodoOverlay();
         void sideConversation?.stopParentObserver?.();
         unsubscribeStartedTurns();
         unsubscribeResolvedInteractions();
@@ -632,10 +678,8 @@ export async function runMakaPiTui(input) {
             rejectClosed(error);
         else
             resolveClosed();
-        // Runtime stop is best-effort after the shell has its terminal back. A
-        // double-Escape/Ctrl-C interrupt may already have one in flight; reuse it.
-        if (!interruptRequested)
-            void input.driver.stop().catch(() => { });
+        // Closing a viewport is not a Turn or Host stop. Explicit interrupt keys
+        // retain their own stop path; an attached Host continues independently.
     };
     const handleProcessExit = (exitCode, error) => {
         process.exitCode = exitCode;
@@ -1210,6 +1254,7 @@ export async function runMakaPiTui(input) {
         });
     }
     const adoptSessionMetadata = (summary, announceIdentity = true) => {
+        syncTodoSession();
         cwd = summary.cwd ?? cwd;
         setSessionTitle(summary.name);
         model = summary.model;
@@ -1298,6 +1343,8 @@ export async function runMakaPiTui(input) {
     // `messages`. Shared by switchSession and rewindToTurn so both land the same
     // runner state (model/connection/thinking/transcript/scroll).
     const applySwitchResult = async ({ summary, messages, activeTurn, }) => {
+        resetTranscriptViewer();
+        closeTodoOverlay();
         adoptSessionMetadata(summary, false);
         replaceTranscript(messages);
         syncInteractionOverlays();
@@ -1857,6 +1904,11 @@ export async function runMakaPiTui(input) {
         formOverlay = showBottomPicker(formOverlayComponent);
     };
     const syncInteractionOverlays = () => {
+        if (state.pendingInteraction) {
+            closeTodoOverlay();
+            transcriptOverlay?.hide();
+            transcriptOverlay = undefined;
+        }
         syncUserQuestionOverlay();
         syncFormOverlay();
     };
@@ -2306,45 +2358,58 @@ export async function runMakaPiTui(input) {
                 foreignByValue.set(`foreign:${summary.source}:${summary.id}`, summary);
             }
         }
+        let overlay;
+        let sessionSearch;
         const renderScope = () => {
             const visibleSessions = sessionListScope === 'current'
                 ? projectedSessions.filter(({ session }) => session.cwd === cwd)
                 : projectedSessions;
-            const items = visibleSessions.map(({ session, depth }) => {
+            const choices = visibleSessions.map(({ session, depth }) => {
                 const state = availability.get(session.id);
                 const statusBadge = sessionStatusBadge(session, locale);
                 const statusDetail = statusBadge ? ` · ${statusBadge}` : '';
-                const location = sessionListScope === 'all' && session.cwd ? ` ${basename(session.cwd)}` : '';
+                const location = sessionListScope === 'all' && session.cwd ? ` ${session.cwd}` : '';
                 const childDetail = session.subagentRuntime
                     ? ` subagent:${session.subagentRuntime.profile}`
                     : '';
-                return {
+                const item = {
                     value: session.id,
                     label: `${depth > 0 ? `${'  '.repeat(depth - 1)}↳ ` : ''}${session.name || session.id}`,
                     description: state?.available === false
                         ? `${shortSessionId(session.id)}${statusDetail} ${state.reason}`
                         : `${shortSessionId(session.id)}${statusDetail}${location}${childDetail} ${session.llmConnectionSlug} ${session.model}`,
                 };
+                return {
+                    item,
+                    searchText: [
+                        session.name,
+                        session.id,
+                        session.cwd,
+                        session.model,
+                        session.llmConnectionSlug,
+                    ]
+                        .filter(Boolean)
+                        .join(' ')
+                        .toLocaleLowerCase(),
+                };
             });
             // Foreign sessions are cwd-scoped; show them in both scope views (they
             // belong to this project) so a Tab toggle never makes them vanish.
             for (const [value, summary] of foreignByValue) {
-                items.push({
-                    value,
-                    label: summary.title,
-                    description: `↩ resume from ${foreignSourceLabel(summary.source)}`,
+                choices.push({
+                    item: {
+                        value,
+                        label: summary.title,
+                        description: `↩ resume from ${foreignSourceLabel(summary.source)}`,
+                    },
+                    searchText: `${summary.title} ${summary.id} ${summary.cwd} ${summary.source}`.toLocaleLowerCase(),
                 });
             }
-            const list = new SelectList(items, 10, selectListTheme(), {
-                minPrimaryColumnWidth: 20,
-                maxPrimaryColumnWidth: Math.max(20, terminal.columns - 30),
-            });
-            let overlay;
             const closeOverlay = () => {
                 sessionPickerOverlayOpen = false;
                 overlay?.hide();
             };
-            list.onSelect = (item) => {
+            const onSelect = (item) => {
                 const foreign = foreignByValue.get(item.value);
                 if (foreign) {
                     closeOverlay();
@@ -2356,21 +2421,27 @@ export async function runMakaPiTui(input) {
                 closeOverlay();
                 void goToSession(item.value);
             };
-            list.onCancel = () => closeOverlay();
-            sessionPickerOverlayOpen = true;
-            overlay = showBottomPicker(new PickerOverlay(list, {
-                title: 'Resume Session',
-                rightLabel: sessionListScope === 'current' ? 'Current' : 'All',
-                hint: 'Tab scope · ↑↓ move · Enter select · Esc close',
-                onInput: (data) => {
-                    if (!matchesKey(data, Key.tab) || isKeyRelease(data) || isKeyRepeat(data))
-                        return false;
+            const scopeLabel = sessionListScope === 'current'
+                ? pickerCopy.sessionScopeCurrent
+                : pickerCopy.sessionScopeAll;
+            if (sessionSearch) {
+                sessionSearch.updateChoices(choices, scopeLabel);
+                sessionSearch.invalidate();
+                return;
+            }
+            sessionSearch = new SessionSearchOverlay(tui, {
+                locale,
+                choices,
+                scopeLabel,
+                onSelect,
+                onCancel: closeOverlay,
+                onToggleScope: () => {
                     sessionListScope = sessionListScope === 'current' ? 'all' : 'current';
-                    overlay?.hide();
                     renderScope();
-                    return true;
                 },
-            }));
+            });
+            sessionPickerOverlayOpen = true;
+            overlay = showBottomPicker(sessionSearch);
         };
         renderScope();
     };
@@ -2428,6 +2499,9 @@ export async function runMakaPiTui(input) {
             requestRender();
             return false;
         }
+        resetTranscriptViewer();
+        closeTodoOverlay();
+        syncTodoSession();
         // A fresh session is not bound by the previous one's boundary. Falling back
         // to the *current* label would keep the previous Session's mode, including
         // Auto while a changed Host default creates with full access; the launch
@@ -2509,20 +2583,42 @@ export async function runMakaPiTui(input) {
         requestRender();
     };
     const showTranscriptViewer = () => {
-        let overlay;
-        const renderTranscript = transcript.createDocumentRenderer();
-        const viewer = new TranscriptViewerOverlay({
-            renderTranscript,
-            viewportRows: () => terminal.rows,
-            onClose: () => overlay?.hide(),
-            onChange: () => tui.requestRender(),
-        });
-        overlay = tui.showOverlay(viewer, {
+        if (state.pendingInteraction)
+            return;
+        const sessionId = input.driver.getSessionId() ?? undefined;
+        if (!transcriptViewer || transcriptViewerSessionId !== sessionId) {
+            transcriptViewerSessionId = sessionId;
+            transcriptViewer = new TranscriptViewerOverlay({
+                renderTranscript: transcript.createDocumentRenderer(),
+                locale,
+                viewportRows: () => terminal.rows,
+                onClose: () => {
+                    transcriptOverlay?.hide();
+                    transcriptOverlay = undefined;
+                },
+                onChange: () => tui.requestRender(),
+            });
+        }
+        transcriptOverlay = tui.showOverlay(transcriptViewer, {
             anchor: 'top-left',
             width: '100%',
             maxHeight: '100%',
         });
     };
+    const showTodo = () => {
+        if (state.pendingInteraction)
+            return;
+        syncTodoSession();
+        void currentTodo.refresh();
+        closeTodoOverlay();
+        todoOverlay = tui.showOverlay(new TodoOverlay({
+            locale,
+            getState: () => input.driver.queryTodo ? currentTodo.getState() : { status: 'error', items: [] },
+            viewportRows: () => terminal.rows,
+            onClose: closeTodoOverlay,
+            onChange: () => tui.requestRender(),
+        }), { anchor: 'top-left', width: '100%', maxHeight: '100%' });
+    };
     const showMcpStatus = () => {
         let overlay;
         const viewer = new McpManagementOverlay({
@@ -2943,7 +3039,78 @@ export async function runMakaPiTui(input) {
             notice('Goal cleared.');
         }
     };
+    const runHostCommand = async (parts) => {
+        const copy = getTuiHostOwnerCopy(locale);
+        if (!input.hostControl)
+            throw new Error(copy.unavailable);
+        const action = parts[1] ?? 'status';
+        if (action === 'status' && parts.length <= 2) {
+            const text = await input.hostControl.status();
+            if (!closed) {
+                state.entries.push({ kind: 'notice', level: 'info', text });
+                requestRender();
+            }
+            return;
+        }
+        if (action !== 'stop' && action !== 'restart' && action !== 'update') {
+            throw new Error(copy.usage);
+        }
+        const targets = parts.slice(2);
+        if (targets.length > (action === 'update' ? 1 : 0)) {
+            throw new Error(copy.usage);
+        }
+        const accepted = await input.hostControl.prepare({
+            action,
+            ...(targets[0] ? { target: targets[0] } : {}),
+        }, (detail) => new Promise((resolve) => {
+            if (closed)
+                return resolve('cancel');
+            showSelectPicker(copy.pickerTitle, 'cancel', [
+                {
+                    value: 'cancel',
+                    label: copy.cancel,
+                    description: copy.cancelDescription,
+                },
+                {
+                    value: 'safe',
+                    label: copy.safe,
+                    description: copy.safeDescription,
+                },
+                ...(action === 'update'
+                    ? []
+                    : [
+                        {
+                            value: 'interrupt',
+                            label: copy.interrupt,
+                            description: copy.interruptDescription,
+                        },
+                    ]),
+            ], (item) => resolve(item.value), {
+                minPrimaryColumnWidth: 16,
+                maxPrimaryColumnWidth: 26,
+                selectedIndex: 0,
+                notice: detail,
+                onCancel: () => resolve('cancel'),
+            });
+        }));
+        if (accepted)
+            beginGracefulClose();
+    };
     const slashCommandHandlers = {
+        host: {
+            description: primaryGuidance.commands.host,
+            midTurn: 'local',
+            run: (parts) => {
+                void runHostCommand(parts).catch(reportError);
+            },
+        },
+        update: {
+            description: primaryGuidance.commands.update,
+            midTurn: 'local',
+            run: (parts) => {
+                void runHostCommand(['/host', 'update', ...parts.slice(1)]).catch(reportError);
+            },
+        },
         context: {
             description: primaryGuidance.commands.context,
             // Read-only diagnostics, but runControl-gated: mid-turn it would
@@ -3241,6 +3408,22 @@ export async function runMakaPiTui(input) {
                 showTranscriptViewer();
             },
         },
+        todo: {
+            description: primaryGuidance.commands.todo,
+            midTurn: 'local',
+            run: (parts) => {
+                if (parts.length !== 1) {
+                    state.entries.push({
+                        kind: 'notice',
+                        level: 'error',
+                        text: TUI_COPY_RESOURCES.todo[locale].usage,
+                    });
+                    requestRender();
+                    return;
+                }
+                showTodo();
+            },
+        },
         permissions: {
             description: primaryGuidance.commands.permissions,
             midTurn: 'refuse',
@@ -3535,9 +3718,8 @@ export async function runMakaPiTui(input) {
         if (!matchesKey(data, Key.escape))
             lastIdleEscapeAt = 0;
         if (matchesKey(data, Key.ctrl('o')) && !isKeyRepeat(data)) {
-            if (handleExpansionToggleKey('tool')) {
-                return { consume: true };
-            }
+            showTranscriptViewer();
+            return { consume: true };
         }
         if (matchesKey(data, Key.ctrl('t')) && !isKeyRepeat(data)) {
             if (handleExpansionToggleKey('thinking')) {
@@ -3648,11 +3830,11 @@ export async function runMakaPiTui(input) {
     // re-wrapping) a full clear would wipe the scrollback the user scrolls through.
     // Differential rendering clears the vacated rows without the wipe.
     //
-    // The Ctrl+O / Ctrl+T toggles are viewport-anchored for the same reason: an
+    // The live Ctrl+T thinking toggle is viewport-anchored for the same reason: an
     // entry above the live viewport lives in terminal scrollback, which cannot
     // be rewritten, so resizing it would push pi-tui's differential renderer
     // into a scrollback-clearing full redraw (its `firstChanged < viewportTop`
-    // path). The toggles therefore retarget only entries inside the viewport;
+    // path). It therefore retargets only entries inside the viewport;
     // see entryInLiveViewport in pi-transcript.ts (#1097). A block whose own
     // expansion pushed its head above the viewport can consequently not be
     // collapsed by the next press (#1134): the toggle still flips the default
@@ -3661,6 +3843,7 @@ export async function runMakaPiTui(input) {
     // again within EXPANSION_COLLAPSE_CONFIRM_WINDOW_MS applies the collapsed
     // default to those blocks too and pays one scrollback-clearing full redraw
     // (requestRender(true)), re-anchoring the viewport at the tail.
+    // Ctrl+O instead opens a detached reader whose details never resize live rows.
     tui.setClearOnShrink(false);
     tui.addChild(layout);
     tui.setFocus(editorSurface);
@@ -3702,6 +3885,7 @@ export async function runMakaPiTui(input) {
             }
         });
     }
+    syncTodoSession();
     return closedPromise;
 }
 const BOTTOM_PICKER_MARGIN_ROWS = 4;

package/dist/pi-tui-todo.js

@@ -0,0 +1,221 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Key, isKeyRelease, isKeyRepeat, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from '@earendil-works/pi-tui';
+import { projectSessionTodoItemsForDisplay, } from '@maka/core/session-todo';
+import { ansi } from './tui-ansi.js';
+import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
+/** Owns only the current session; late queries cannot cross session changes or disposal. */
+export class CurrentTodoStore {
+    reader;
+    onChange;
+    snapshot = { status: 'idle', items: [] };
+    generation = 0;
+    disposed = false;
+    pending;
+    refreshAgain = false;
+    constructor(reader, onChange = () => undefined) {
+        this.reader = reader;
+        this.onChange = onChange;
+    }
+    getState() {
+        return this.snapshot;
+    }
+    setSession(sessionId) {
+        if (this.disposed || this.snapshot.sessionId === sessionId)
+            return;
+        this.generation++;
+        this.pending = undefined;
+        this.refreshAgain = false;
+        this.publish({ status: 'idle', ...(sessionId ? { sessionId } : {}), items: [] });
+        if (sessionId)
+            void this.refresh();
+    }
+    refresh() {
+        const { sessionId } = this.snapshot;
+        if (this.disposed || !sessionId)
+            return Promise.resolve(false);
+        if (this.pending) {
+            this.refreshAgain = true;
+            return this.pending;
+        }
+        const pending = this.load(sessionId, this.generation).finally(() => {
+            if (this.pending !== pending)
+                return;
+            this.pending = undefined;
+            if (this.refreshAgain) {
+                this.refreshAgain = false;
+                void this.refresh();
+            }
+        });
+        this.pending = pending;
+        return pending;
+    }
+    dispose() {
+        this.disposed = true;
+        this.generation++;
+        this.pending = undefined;
+        this.refreshAgain = false;
+        this.snapshot = { status: 'idle', items: [] };
+    }
+    async load(sessionId, generation) {
+        // Keep current data visible during background refreshes, without a second cache.
+        if (this.snapshot.status !== 'ready' && this.snapshot.status !== 'empty') {
+            this.publish({ status: 'loading', sessionId, items: [] });
+        }
+        try {
+            const result = await this.reader.read(sessionId);
+            if (generation !== this.generation)
+                return false;
+            const items = projectSessionTodoItemsForDisplay(result.items);
+            this.publish({ status: items.length ? 'ready' : 'empty', sessionId, items });
+        }
+        catch {
+            if (generation !== this.generation)
+                return false;
+            this.publish({ status: 'error', sessionId, items: [] });
+        }
+        return true;
+    }
+    publish(snapshot) {
+        this.snapshot = snapshot;
+        this.onChange();
+    }
+}
+/** Render the one-line current Todo indicator. Empty and initial states stay hidden. */
+export function renderTodoIndicator(snapshot, input) {
+    const copy = TUI_COPY_RESOURCES.todo[input.locale];
+    if (snapshot.status === 'idle' || snapshot.status === 'loading' || snapshot.status === 'empty') {
+        return undefined;
+    }
+    if (snapshot.status === 'error')
+        return fitLine(`${copy.unavailable} · ${copy.open}`, input.width);
+    const current = snapshot.items.find((item) => item.status === 'in_progress');
+    const completed = snapshot.items.filter((item) => item.status === 'completed').length;
+    const suffix = `${copy.progress} ${completed}/${snapshot.items.length} · ${copy.open}`;
+    const prefix = current ? `${ansi.accent('◐')} ` : '';
+    const available = input.width - visibleWidth(prefix) - visibleWidth(suffix) - (current ? 3 : 1);
+    if (!current)
+        return fitLine(suffix, input.width);
+    if (available < 1)
+        return fitLine(suffix, input.width);
+    const content = truncateToWidth(current.content, Math.max(1, available), '…');
+    return fitLine(`${prefix}${content} · ${suffix}`, input.width);
+}
+/** Read-only, scrollable view of the current Todo projection. */
+export class TodoOverlay {
+    input;
+    top = 0;
+    bodyRows = 1;
+    width = 80;
+    constructor(input) {
+        this.input = input;
+    }
+    invalidate() { }
+    handleInput(data) {
+        if (isKeyRelease(data))
+            return;
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))) {
+            if (!isKeyRepeat(data))
+                this.input.onClose();
+            return;
+        }
+        if (matchesKey(data, Key.up))
+            this.scrollBy(-1);
+        else if (matchesKey(data, Key.down))
+            this.scrollBy(1);
+        else if (matchesKey(data, Key.pageUp))
+            this.scrollBy(-this.bodyRows);
+        else if (matchesKey(data, Key.pageDown))
+            this.scrollBy(this.bodyRows);
+        else if (matchesKey(data, Key.home)) {
+            this.scrollTo(0);
+            this.input.onChange?.();
+        }
+        else if (matchesKey(data, Key.end)) {
+            this.scrollTo(Number.MAX_SAFE_INTEGER);
+            this.input.onChange?.();
+        }
+    }
+    render(width) {
+        const safeWidth = Math.max(1, width);
+        this.width = safeWidth;
+        const copy = TUI_COPY_RESOURCES.todo[this.input.locale];
+        const viewport = Math.max(1, Math.floor(this.input.viewportRows()));
+        const showFooter = viewport > 2;
+        this.bodyRows = Math.max(0, viewport - (showFooter ? 2 : 1));
+        const snapshot = this.input.getState();
+        const rows = this.rows(snapshot, safeWidth);
+        const maxTop = Math.max(0, rows.length - this.bodyRows);
+        this.top = Math.min(this.top, maxTop);
+        const visible = rows.slice(this.top, this.top + this.bodyRows);
+        const completed = snapshot.items.filter((item) => item.status === 'completed').length;
+        const summary = snapshot.status === 'ready'
+            ? ` · ${completed}/${snapshot.items.length} ${copy.markedComplete}`
+            : '';
+        const position = rows.length > this.bodyRows && this.bodyRows > 0
+            ? ` · ${this.top + 1}-${this.top + visible.length}/${rows.length}`
+            : '';
+        const header = padLine(`${ansi.bold(copy.title)}${summary}${ansi.dim(position)}`, safeWidth);
+        const body = [
+            ...visible,
+            ...Array.from({ length: this.bodyRows - visible.length }, () => ' '.repeat(safeWidth)),
+        ];
+        if (!showFooter)
+            return [header, ...body];
+        const footer = padLine(ansi.dim(copy.hint), safeWidth);
+        return [header, ...body, footer];
+    }
+    rows(snapshot, width) {
+        const copy = TUI_COPY_RESOURCES.todo[this.input.locale];
+        if (snapshot.status === 'loading')
+            return [padLine(copy.loading, width)];
+        if (snapshot.status === 'error')
+            return [padLine(copy.unavailable, width)];
+        if (snapshot.status === 'idle' || snapshot.status === 'empty')
+            return [padLine(copy.empty, width)];
+        return snapshot.items.flatMap((item) => {
+            const symbol = item.status === 'completed'
+                ? ansi.green('✓')
+                : item.status === 'in_progress'
+                    ? ansi.accent('●')
+                    : ansi.muted('○');
+            return wrapTodoItem(`${symbol} `, item.content, width);
+        });
+    }
+    scrollBy(delta) {
+        this.scrollTo(this.top + delta);
+        this.input.onChange?.();
+    }
+    scrollTo(top) {
+        const rows = this.rows(this.input.getState(), this.width);
+        this.top = Math.max(0, Math.min(top, Math.max(0, rows.length - this.bodyRows)));
+    }
+}
+function wrapTodoItem(prefix, content, width) {
+    const lines = wrapTextWithAnsi(content, Math.max(1, width - 2));
+    return (lines.length ? lines : ['']).map((line, index) => padLine(`${index === 0 ? prefix : '  '}${line}`, width));
+}
+function fitLine(text, width) {
+    return truncateToWidth(text, Math.max(1, width), '…');
+}
+function padLine(text, width) {
+    const safeWidth = Math.max(1, width);
+    const trimmed = fitLine(text, safeWidth);
+    return `${trimmed}${' '.repeat(Math.max(0, safeWidth - visibleWidth(trimmed)))}`;
+}