aoaoe 0.71.0 → 0.73.0

package/dist/index.js

@@ -15,7 +15,7 @@ import { wakeableSleep } from "./wake.js";
 import { classifyMessages, formatUserMessages, buildReceipts, shouldSkipSleep, hasPendingFile, isInsistMessage, stripInsistPrefix } from "./message.js";
 import { TaskManager, loadTaskDefinitions, loadTaskState, formatTaskTable } from "./task-manager.js";
 import { runTaskCli, handleTaskSlashCommand } from "./task-cli.js";
-import { TUI } from "./tui.js";
+import { TUI, hitTestSession } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
@@ -256,19 +256,36 @@ async function main() {
     // wire scroll keys to TUI (PgUp/PgDn/Home/End)
     if (tui) {
         input.onScroll((dir) => {
-            switch (dir) {
-                case "up":
-                    tui.scrollUp();
-                    break;
-                case "down":
-                    tui.scrollDown();
-                    break;
-                case "top":
-                    tui.scrollToTop();
-                    break;
-                case "bottom":
-                    tui.scrollToBottom();
-                    break;
+            if (tui.getViewMode() === "drilldown") {
+                // PgUp/PgDn/Home/End scroll the session output in drill-down mode
+                switch (dir) {
+                    case "up":
+                        tui.scrollDrilldownUp();
+                        break;
+                    case "down":
+                        tui.scrollDrilldownDown();
+                        break;
+                    case "bottom":
+                        tui.scrollDrilldownToBottom();
+                        break;
+                    // "top" not wired for drilldown — could add scrollDrilldownToTop() later
+                }
+            }
+            else {
+                switch (dir) {
+                    case "up":
+                        tui.scrollUp();
+                        break;
+                    case "down":
+                        tui.scrollDown();
+                        break;
+                    case "top":
+                        tui.scrollToTop();
+                        break;
+                    case "bottom":
+                        tui.scrollToBottom();
+                        break;
+                }
             }
         });
         // wire queue count changes to TUI prompt display
@@ -293,6 +310,36 @@ async function main() {
                 }
             }
         });
+        // wire mouse clicks on session cards to drill-down
+        input.onMouseClick((row, _col) => {
+            if (tui.getViewMode() === "drilldown") {
+                // click anywhere in drilldown = back to overview
+                tui.exitDrilldown();
+                tui.log("system", "returned to overview");
+                return;
+            }
+            const sessionIdx = hitTestSession(row, 1, tui.getSessionCount());
+            if (sessionIdx !== null) {
+                const ok = tui.enterDrilldown(sessionIdx);
+                if (ok)
+                    tui.log("system", `viewing session #${sessionIdx}`);
+            }
+        });
+        // wire mouse wheel to scroll (3 lines per tick for smooth scrolling)
+        input.onMouseWheel((direction) => {
+            if (tui.getViewMode() === "drilldown") {
+                if (direction === "up")
+                    tui.scrollDrilldownUp(3);
+                else
+                    tui.scrollDrilldownDown(3);
+            }
+            else {
+                if (direction === "up")
+                    tui.scrollUp(3);
+                else
+                    tui.scrollDown(3);
+            }
+        });
     }
     // start TUI (alternate screen buffer) after input is ready
     if (tui) {

package/dist/input.d.ts

@@ -1,6 +1,16 @@
 export type ScrollDirection = "up" | "down" | "top" | "bottom";
 export declare const INSIST_PREFIX = "__INSIST__";
 export type ViewHandler = (target: string | null) => void;
+export interface MouseEvent {
+    button: number;
+    col: number;
+    row: number;
+    press: boolean;
+}
+export type MouseClickHandler = (row: number, col: number) => void;
+export type MouseWheelHandler = (direction: "up" | "down") => void;
+/** Parse an SGR extended mouse event from raw terminal data. Returns null if not a mouse event. */
+export declare function parseMouseEvent(data: string): MouseEvent | null;
 export declare class InputReader {
     private rl;
     private queue;
@@ -9,9 +19,14 @@ export declare class InputReader {
     private scrollHandler;
     private queueChangeHandler;
     private viewHandler;
+    private mouseClickHandler;
+    private mouseWheelHandler;
+    private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
     onQueueChange(handler: (count: number) => void): void;
     onView(handler: ViewHandler): void;
+    onMouseClick(handler: MouseClickHandler): void;
+    onMouseWheel(handler: MouseWheelHandler): void;
     private notifyQueueChange;
     start(): void;
     drain(): string[];

package/dist/input.js

@@ -7,6 +7,20 @@ import { GREEN, DIM, YELLOW, RED, BOLD, RESET } from "./colors.js";
 // ESC-ESC interrupt detection
 const ESC_DOUBLE_TAP_MS = 500;
 export const INSIST_PREFIX = "__INSIST__";
+// SGR extended mouse format: \x1b[<btn;col;rowM (press) or \x1b[<btn;col;rowm (release)
+const SGR_MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
+/** Parse an SGR extended mouse event from raw terminal data. Returns null if not a mouse event. */
+export function parseMouseEvent(data) {
+    const m = SGR_MOUSE_RE.exec(data);
+    if (!m)
+        return null;
+    return {
+        button: parseInt(m[1], 10),
+        col: parseInt(m[2], 10),
+        row: parseInt(m[3], 10),
+        press: m[4] === "M",
+    };
+}
 export class InputReader {
     rl = null;
     queue = []; // pending user messages for the reasoner
@@ -15,6 +29,9 @@ export class InputReader {
     scrollHandler = null;
     queueChangeHandler = null;
     viewHandler = null;
+    mouseClickHandler = null;
+    mouseWheelHandler = null;
+    mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
     onScroll(handler) {
         this.scrollHandler = handler;
@@ -27,6 +44,14 @@ export class InputReader {
     onView(handler) {
         this.viewHandler = handler;
     }
+    // register a callback for mouse left-click events (row, col are 1-indexed)
+    onMouseClick(handler) {
+        this.mouseClickHandler = handler;
+    }
+    // register a callback for mouse wheel events (scroll up/down)
+    onMouseWheel(handler) {
+        this.mouseWheelHandler = handler;
+    }
     notifyQueueChange() {
         this.queueChangeHandler?.(this.queue.length);
     }
@@ -44,6 +69,25 @@ export class InputReader {
         this.rl.on("close", () => { this.rl = null; });
         // ESC-ESC interrupt detection (same as chat.ts)
         emitKeypressEvents(process.stdin);
+        // intercept raw SGR mouse sequences before keypress parsing
+        this.mouseDataListener = (data) => {
+            const str = data.toString("utf8");
+            const evt = parseMouseEvent(str);
+            if (!evt)
+                return;
+            // left click press
+            if (evt.press && evt.button === 0 && this.mouseClickHandler) {
+                this.mouseClickHandler(evt.row, evt.col);
+            }
+            // mouse wheel: button 64 = scroll up, 65 = scroll down
+            if (evt.button === 64 && this.mouseWheelHandler) {
+                this.mouseWheelHandler("up");
+            }
+            else if (evt.button === 65 && this.mouseWheelHandler) {
+                this.mouseWheelHandler("down");
+            }
+        };
+        process.stdin.on("data", this.mouseDataListener);
         process.stdin.on("keypress", (_ch, key) => {
             if (key?.name === "escape" || key?.sequence === "\x1b") {
                 const now = Date.now();
@@ -102,6 +146,10 @@ export class InputReader {
         this.rl?.prompt(true);
     }
     stop() {
+        if (this.mouseDataListener) {
+            process.stdin.removeListener("data", this.mouseDataListener);
+            this.mouseDataListener = null;
+        }
         this.rl?.close();
         this.rl = null;
     }
@@ -167,7 +215,9 @@ ${BOLD}controls:${RESET}
 ${BOLD}navigation:${RESET}
   /view [N|name]     drill into a session's live output (default: 1)
   /back              return to overview from drill-down
-  PgUp / PgDn        scroll through activity history
+  click session      click an agent card to drill down (click again to go back)
+  mouse wheel        scroll activity (overview) or session output (drill-down)
+  PgUp / PgDn        scroll through activity or session output
   Home / End         jump to oldest / return to live
 
 ${BOLD}info:${RESET}

package/dist/tui.d.ts

@@ -26,6 +26,8 @@ export declare class TUI {
     private viewMode;
     private drilldownSessionId;
     private sessionOutputs;
+    private drilldownScrollOffset;
+    private drilldownNewWhileScrolled;
     private phase;
     private pollCount;
     private sessions;
@@ -36,6 +38,8 @@ export declare class TUI {
     start(version: string): void;
     stop(): void;
     isActive(): boolean;
+    /** Return the current number of sessions (for mouse hit testing) */
+    getSessionCount(): number;
     updateState(opts: {
         phase?: DaemonPhase;
         pollCount?: number;
@@ -52,6 +56,10 @@ export declare class TUI {
     scrollToTop(): void;
     scrollToBottom(): void;
     isScrolledBack(): boolean;
+    scrollDrilldownUp(lines?: number): void;
+    scrollDrilldownDown(lines?: number): void;
+    scrollDrilldownToBottom(): void;
+    isDrilldownScrolledBack(): boolean;
     /** Store full session outputs (called each tick from main loop) */
     setSessionOutputs(outputs: Map<string, string>): void;
     /** Enter drill-down view for a session. Returns false if session not found. */
@@ -94,5 +102,14 @@ declare function computeScrollSlice(bufferLen: number, visibleLines: number, scr
     end: number;
 };
 declare function formatScrollIndicator(offset: number, totalEntries: number, visibleLines: number, newCount: number): string;
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt, formatDrilldownHeader };
+declare function formatDrilldownScrollIndicator(offset: number, totalLines: number, visibleLines: number, newCount: number): string;
+/**
+ * Hit-test a mouse click row against the session panel.
+ * Returns 1-indexed session number if the click hit a session card, null otherwise.
+ *
+ * Session cards occupy rows: headerHeight + 2 through headerHeight + 1 + sessionCount
+ * (row = headerHeight + 2 + i for 0-indexed session i)
+ */
+export declare function hitTestSession(row: number, headerHeight: number, sessionCount: number): number | null;
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatDrilldownScrollIndicator, formatPrompt, formatDrilldownHeader };
 //# sourceMappingURL=tui.d.ts.map

package/dist/tui.js

@@ -12,6 +12,9 @@ const CURSOR_HIDE = `${CSI}?25l`;
 const CURSOR_SHOW = `${CSI}?25h`;
 const SAVE_CURSOR = `${ESC}7`;
 const RESTORE_CURSOR = `${ESC}8`;
+// mouse tracking (SGR extended mode — button events + extended coordinates)
+const MOUSE_ON = `${CSI}?1000h${CSI}?1006h`;
+const MOUSE_OFF = `${CSI}?1000l${CSI}?1006l`;
 // cursor movement
 const moveTo = (row, col) => `${CSI}${row};${col}H`;
 const setScrollRegion = (top, bottom) => `${CSI}${top};${bottom}r`;
@@ -62,6 +65,8 @@ export class TUI {
     viewMode = "overview";
     drilldownSessionId = null;
     sessionOutputs = new Map(); // full output lines per session
+    drilldownScrollOffset = 0; // 0 = live (tail), >0 = scrolled back N lines
+    drilldownNewWhileScrolled = 0; // lines added while scrolled back
     // current state for repaints
     phase = "sleeping";
     pollCount = 0;
@@ -76,8 +81,8 @@ export class TUI {
         this.active = true;
         this.version = version;
         this.updateDimensions();
-        // enter alternate screen, hide cursor, clear
-        process.stderr.write(ALT_SCREEN_ON + CURSOR_HIDE + CLEAR_SCREEN);
+        // enter alternate screen, hide cursor, clear, enable mouse
+        process.stderr.write(ALT_SCREEN_ON + CURSOR_HIDE + CLEAR_SCREEN + MOUSE_ON);
         // handle terminal resize
         process.stdout.on("resize", () => this.onResize());
         // tick timer: countdown + spinner animation (~4 fps for smooth braille spin)
@@ -102,12 +107,16 @@ export class TUI {
             clearInterval(this.countdownTimer);
             this.countdownTimer = null;
         }
-        // restore normal screen, show cursor, reset scroll region
-        process.stderr.write(resetScrollRegion() + CURSOR_SHOW + ALT_SCREEN_OFF);
+        // disable mouse, restore normal screen, show cursor, reset scroll region
+        process.stderr.write(MOUSE_OFF + resetScrollRegion() + CURSOR_SHOW + ALT_SCREEN_OFF);
     }
     isActive() {
         return this.active;
     }
+    /** Return the current number of sessions (for mouse hit testing) */
+    getSessionCount() {
+        return this.sessions.length;
+    }
     // ── State updates ───────────────────────────────────────────────────────
     updateState(opts) {
         if (opts.phase !== undefined)
@@ -214,15 +223,58 @@ export class TUI {
     isScrolledBack() {
         return this.scrollOffset > 0;
     }
+    // ── Drill-down scroll ─────────────────────────────────────────────────
+    scrollDrilldownUp(lines) {
+        if (!this.active || this.viewMode !== "drilldown" || !this.drilldownSessionId)
+            return;
+        const outputLines = this.sessionOutputs.get(this.drilldownSessionId) ?? [];
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        const n = lines ?? Math.max(1, Math.floor(visibleLines / 2));
+        const maxOffset = Math.max(0, outputLines.length - visibleLines);
+        this.drilldownScrollOffset = Math.min(maxOffset, this.drilldownScrollOffset + n);
+        this.repaintDrilldownContent();
+        this.paintDrilldownSeparator();
+    }
+    scrollDrilldownDown(lines) {
+        if (!this.active || this.viewMode !== "drilldown")
+            return;
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        const n = lines ?? Math.max(1, Math.floor(visibleLines / 2));
+        const wasScrolled = this.drilldownScrollOffset > 0;
+        this.drilldownScrollOffset = Math.max(0, this.drilldownScrollOffset - n);
+        if (wasScrolled && this.drilldownScrollOffset === 0)
+            this.drilldownNewWhileScrolled = 0;
+        this.repaintDrilldownContent();
+        this.paintDrilldownSeparator();
+    }
+    scrollDrilldownToBottom() {
+        if (!this.active || this.viewMode !== "drilldown")
+            return;
+        this.drilldownScrollOffset = 0;
+        this.drilldownNewWhileScrolled = 0;
+        this.repaintDrilldownContent();
+        this.paintDrilldownSeparator();
+    }
+    isDrilldownScrolledBack() {
+        return this.drilldownScrollOffset > 0;
+    }
     // ── Drill-down mode ────────────────────────────────────────────────────
     /** Store full session outputs (called each tick from main loop) */
     setSessionOutputs(outputs) {
         for (const [id, text] of outputs) {
-            this.sessionOutputs.set(id, text.split("\n"));
+            const prevLen = this.sessionOutputs.get(id)?.length ?? 0;
+            const lines = text.split("\n");
+            this.sessionOutputs.set(id, lines);
+            // track new lines while scrolled back in drill-down
+            if (this.viewMode === "drilldown" && this.drilldownSessionId === id && this.drilldownScrollOffset > 0) {
+                const newLines = Math.max(0, lines.length - prevLen);
+                this.drilldownNewWhileScrolled += newLines;
+            }
         }
         // repaint drill-down view if we're watching this session
         if (this.active && this.viewMode === "drilldown" && this.drilldownSessionId) {
             this.repaintDrilldownContent();
+            this.paintDrilldownSeparator();
         }
     }
     /** Enter drill-down view for a session. Returns false if session not found. */
@@ -244,6 +296,8 @@ export class TUI {
             return false;
         this.viewMode = "drilldown";
         this.drilldownSessionId = sessionId;
+        this.drilldownScrollOffset = 0;
+        this.drilldownNewWhileScrolled = 0;
         if (this.active) {
             this.computeLayout(this.sessions.length);
             this.paintAll();
@@ -256,6 +310,8 @@ export class TUI {
             return;
         this.viewMode = "overview";
         this.drilldownSessionId = null;
+        this.drilldownScrollOffset = 0;
+        this.drilldownNewWhileScrolled = 0;
         if (this.active) {
             this.computeLayout(this.sessions.length);
             this.paintAll();
@@ -383,7 +439,7 @@ export class TUI {
             hints = formatScrollIndicator(this.scrollOffset, this.activityBuffer.length, this.scrollBottom - this.scrollTop + 1, this.newWhileScrolled);
         }
         else {
-            hints = " esc esc: interrupt  /help  /explain  /pause ";
+            hints = " click agent to view  esc esc: interrupt  /help ";
         }
         const totalLen = prefix.length + hints.length;
         const fill = Math.max(0, this.cols - totalLen);
@@ -421,7 +477,15 @@ export class TUI {
         const session = this.sessions.find((s) => s.id === this.drilldownSessionId);
         const title = session ? session.title : this.drilldownSessionId ?? "?";
         const prefix = `${BOX.h}${BOX.h} ${title} `;
-        const hints = " /back: overview  /view N: switch session ";
+        let hints;
+        if (this.drilldownScrollOffset > 0) {
+            const outputLines = this.sessionOutputs.get(this.drilldownSessionId ?? "") ?? [];
+            const visibleLines = this.scrollBottom - this.scrollTop + 1;
+            hints = formatDrilldownScrollIndicator(this.drilldownScrollOffset, outputLines.length, visibleLines, this.drilldownNewWhileScrolled);
+        }
+        else {
+            hints = " click or /back: overview  scroll: navigate  /view N: switch ";
+        }
         const totalLen = prefix.length + hints.length;
         const fill = Math.max(0, this.cols - totalLen);
         const left = Math.floor(fill / 2);
@@ -434,9 +498,9 @@ export class TUI {
             return;
         const outputLines = this.sessionOutputs.get(this.drilldownSessionId) ?? [];
         const visibleLines = this.scrollBottom - this.scrollTop + 1;
-        // show the last N lines (tail view, like following output)
-        const startIdx = Math.max(0, outputLines.length - visibleLines);
-        const visible = outputLines.slice(startIdx);
+        // use scroll offset: 0 = tail (live), >0 = scrolled back
+        const { start, end } = computeScrollSlice(outputLines.length, visibleLines, this.drilldownScrollOffset);
+        const visible = outputLines.slice(start, end);
         for (let i = 0; i < visibleLines; i++) {
             const row = this.scrollTop + i;
             if (i < visible.length) {
@@ -639,6 +703,29 @@ function formatScrollIndicator(offset, totalEntries, visibleLines, newCount) {
     const newTag = newCount > 0 ? `  ${newCount} new ↓` : "";
     return ` ↑ ${offset} older  │  ${position}/${totalEntries}  │  PgUp/PgDn  End=live${newTag} `;
 }
+// format the scroll indicator for drill-down separator bar
+function formatDrilldownScrollIndicator(offset, totalLines, visibleLines, newCount) {
+    const position = totalLines - offset;
+    const newTag = newCount > 0 ? `  ${newCount} new ↓` : "";
+    return ` ↑ ${offset} lines  │  ${position}/${totalLines}  │  scroll: navigate  End=live${newTag} `;
+}
+// ── Mouse hit testing (pure, exported for testing) ──────────────────────────
+/**
+ * Hit-test a mouse click row against the session panel.
+ * Returns 1-indexed session number if the click hit a session card, null otherwise.
+ *
+ * Session cards occupy rows: headerHeight + 2 through headerHeight + 1 + sessionCount
+ * (row = headerHeight + 2 + i for 0-indexed session i)
+ */
+export function hitTestSession(row, headerHeight, sessionCount) {
+    if (sessionCount <= 0)
+        return null;
+    const firstSessionRow = headerHeight + 2; // top border is headerHeight+1, first card is +2
+    const lastSessionRow = firstSessionRow + sessionCount - 1;
+    if (row < firstSessionRow || row > lastSessionRow)
+        return null;
+    return row - firstSessionRow + 1; // 1-indexed
+}
 // ── Exported pure helpers (for testing) ─────────────────────────────────────
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt, formatDrilldownHeader };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatDrilldownScrollIndicator, formatPrompt, formatDrilldownHeader };
 //# sourceMappingURL=tui.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aoaoe",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",