aoaoe 0.81.0 → 0.83.0

package/dist/index.js

@@ -378,6 +378,44 @@ async function main() {
             tui.setCompact(enabled);
             tui.log("system", `compact mode: ${enabled ? "on" : "off"}`);
         });
+        // wire /mark bookmark
+        input.onMark(() => {
+            const num = tui.addBookmark();
+            if (num > 0) {
+                tui.log("system", `bookmark #${num} saved`);
+            }
+            else {
+                tui.log("system", "nothing to bookmark (activity buffer empty)");
+            }
+        });
+        // wire /jump to bookmark
+        input.onJump((num) => {
+            const ok = tui.jumpToBookmark(num);
+            if (ok) {
+                tui.log("system", `jumped to bookmark #${num}`);
+            }
+            else {
+                tui.log("system", `bookmark #${num} not found`);
+            }
+        });
+        // wire /marks listing
+        input.onMarks(() => {
+            const bms = tui.getBookmarks();
+            if (bms.length === 0) {
+                tui.log("system", "no bookmarks — use /mark to save one");
+            }
+            else {
+                for (let i = 0; i < bms.length; i++) {
+                    tui.log("system", `  #${i + 1}: ${bms[i].label}`);
+                }
+            }
+        });
+        // wire /focus toggle
+        input.onFocus(() => {
+            const enabled = !tui.isFocused();
+            tui.setFocus(enabled);
+            tui.log("system", `focus mode: ${enabled ? "on (pinned only)" : "off (all sessions)"}`);
+        });
         // wire /bell toggle
         input.onBell(() => {
             const enabled = !tui.isBellEnabled();

package/dist/input.d.ts

@@ -7,6 +7,10 @@ export type SortHandler = (mode: string | null) => void;
 export type CompactHandler = () => void;
 export type PinHandler = (target: string) => void;
 export type BellHandler = () => void;
+export type FocusHandler = () => void;
+export type MarkHandler = () => void;
+export type JumpHandler = (num: number) => void;
+export type MarksHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -36,6 +40,10 @@ export declare class InputReader {
     private compactHandler;
     private pinHandler;
     private bellHandler;
+    private focusHandler;
+    private markHandler;
+    private jumpHandler;
+    private marksHandler;
     private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
     onQueueChange(handler: (count: number) => void): void;
@@ -49,6 +57,10 @@ export declare class InputReader {
     onCompact(handler: CompactHandler): void;
     onPin(handler: PinHandler): void;
     onBell(handler: BellHandler): void;
+    onFocus(handler: FocusHandler): void;
+    onMark(handler: MarkHandler): void;
+    onJump(handler: JumpHandler): void;
+    onMarks(handler: MarksHandler): void;
     private notifyQueueChange;
     start(): void;
     drain(): string[];

package/dist/input.js

@@ -39,6 +39,10 @@ export class InputReader {
     compactHandler = null;
     pinHandler = null;
     bellHandler = null;
+    focusHandler = null;
+    markHandler = null;
+    jumpHandler = null;
+    marksHandler = null;
     mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
     onScroll(handler) {
@@ -88,6 +92,22 @@ export class InputReader {
     onBell(handler) {
         this.bellHandler = handler;
     }
+    // register a callback for focus mode toggle (/focus)
+    onFocus(handler) {
+        this.focusHandler = handler;
+    }
+    // register a callback for adding bookmarks (/mark)
+    onMark(handler) {
+        this.markHandler = handler;
+    }
+    // register a callback for jumping to bookmarks (/jump N)
+    onJump(handler) {
+        this.jumpHandler = handler;
+    }
+    // register a callback for listing bookmarks (/marks)
+    onMarks(handler) {
+        this.marksHandler = handler;
+    }
     notifyQueueChange() {
         this.queueChangeHandler?.(this.queue.length);
     }
@@ -269,6 +289,10 @@ ${BOLD}navigation:${RESET}
   /compact           toggle compact mode (dense session panel)
   /pin [N|name]      pin/unpin a session to the top (toggle)
   /bell              toggle terminal bell on errors/completions
+  /focus             toggle focus mode (show only pinned sessions)
+  /mark              bookmark current activity position
+  /jump N            jump to bookmark N
+  /marks             list all bookmarks
   /search <pattern>  filter activity entries by substring (case-insensitive)
   /search            clear active search filter
   click session      click an agent card to drill down (click again to go back)
@@ -389,6 +413,44 @@ ${BOLD}other:${RESET}
                     console.error(`${DIM}bell not available (no TUI)${RESET}`);
                 }
                 break;
+            case "/focus":
+                if (this.focusHandler) {
+                    this.focusHandler();
+                }
+                else {
+                    console.error(`${DIM}focus not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/mark":
+                if (this.markHandler) {
+                    this.markHandler();
+                }
+                else {
+                    console.error(`${DIM}bookmarks not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/jump": {
+                const jumpArg = line.slice("/jump".length).trim();
+                const jumpNum = parseInt(jumpArg, 10);
+                if (this.jumpHandler && !isNaN(jumpNum) && jumpNum > 0) {
+                    this.jumpHandler(jumpNum);
+                }
+                else if (!this.jumpHandler) {
+                    console.error(`${DIM}bookmarks not available (no TUI)${RESET}`);
+                }
+                else {
+                    console.error(`${DIM}usage: /jump N — jump to bookmark number N${RESET}`);
+                }
+                break;
+            }
+            case "/marks":
+                if (this.marksHandler) {
+                    this.marksHandler();
+                }
+                else {
+                    console.error(`${DIM}bookmarks not available (no TUI)${RESET}`);
+                }
+                break;
             case "/search": {
                 const searchArg = line.slice("/search".length).trim();
                 if (this.searchHandler) {

package/dist/tui.d.ts

@@ -10,6 +10,18 @@ declare function nextSortMode(current: SortMode): SortMode;
 export declare const BELL_COOLDOWN_MS = 5000;
 /** Determine if an activity entry should trigger a terminal bell. High-signal events only. */
 export declare function shouldBell(tag: string, text: string): boolean;
+export interface Bookmark {
+    index: number;
+    label: string;
+}
+/** Max number of bookmarks. */
+export declare const MAX_BOOKMARKS = 20;
+/**
+ * Compute the scroll offset needed to show a bookmarked entry.
+ * Centers the entry in the visible region when possible.
+ * Returns 0 (live) if the entry is within the visible tail.
+ */
+export declare function computeBookmarkOffset(bookmarkIndex: number, bufferLen: number, visibleLines: number): number;
 /** Max name length in compact token. */
 declare const COMPACT_NAME_LEN = 10;
 /** Pin indicator for pinned sessions. */
@@ -53,6 +65,8 @@ export declare class TUI {
     private prevLastActivity;
     private compactMode;
     private pinnedIds;
+    private focusMode;
+    private bookmarks;
     private bellEnabled;
     private lastBellAt;
     private viewMode;
@@ -70,7 +84,7 @@ export declare class TUI {
     start(version: string): void;
     stop(): void;
     isActive(): boolean;
-    /** Return the current number of sessions (for mouse hit testing) */
+    /** Return the current number of visible sessions (for mouse hit testing) */
     getSessionCount(): number;
     /** Set the session sort mode and repaint. */
     setSortMode(mode: SortMode): void;
@@ -89,10 +103,30 @@ export declare class TUI {
     isPinned(id: string): boolean;
     /** Return count of pinned sessions. */
     getPinnedCount(): number;
+    /** Enable or disable focus mode. When focused, only pinned sessions are visible. */
+    setFocus(enabled: boolean): void;
+    /** Return whether focus mode is enabled. */
+    isFocused(): boolean;
+    /** Return count of visible sessions (all in normal mode, pinned-only in focus mode). */
+    private getVisibleCount;
     /** Enable or disable terminal bell notifications. */
     setBell(enabled: boolean): void;
     /** Return whether terminal bell is enabled. */
     isBellEnabled(): boolean;
+    /**
+     * Add a bookmark at the current activity position.
+     * Returns the bookmark number (1-indexed) or 0 if buffer is empty.
+     */
+    addBookmark(): number;
+    /**
+     * Jump to a bookmark by number (1-indexed). Returns false if not found.
+     * Adjusts scroll offset to center the bookmarked entry.
+     */
+    jumpToBookmark(num: number): boolean;
+    /** Return all bookmarks (for /marks listing). */
+    getBookmarks(): readonly Bookmark[];
+    /** Return bookmark count. */
+    getBookmarkCount(): number;
     updateState(opts: {
         phase?: DaemonPhase;
         pollCount?: number;

package/dist/tui.js

@@ -63,6 +63,23 @@ export function shouldBell(tag, text) {
         return true;
     return false;
 }
+/** Max number of bookmarks. */
+export const MAX_BOOKMARKS = 20;
+/**
+ * Compute the scroll offset needed to show a bookmarked entry.
+ * Centers the entry in the visible region when possible.
+ * Returns 0 (live) if the entry is within the visible tail.
+ */
+export function computeBookmarkOffset(bookmarkIndex, bufferLen, visibleLines) {
+    // entry position from the end of the buffer
+    const fromEnd = bufferLen - 1 - bookmarkIndex;
+    // if entry is within the visible tail, no scroll needed
+    if (fromEnd < visibleLines)
+        return 0;
+    // center the entry in the visible region
+    const half = Math.floor(visibleLines / 2);
+    return Math.max(0, fromEnd - half);
+}
 // ── Compact mode ────────────────────────────────────────────────────────────
 /** Max name length in compact token. */
 const COMPACT_NAME_LEN = 10;
@@ -161,6 +178,8 @@ export class TUI {
     prevLastActivity = new Map(); // session ID → previous lastActivity string
     compactMode = false;
     pinnedIds = new Set(); // pinned session IDs (always sort to top)
+    focusMode = false; // focus mode: hide all sessions except pinned
+    bookmarks = []; // saved positions in activity buffer
     bellEnabled = false;
     lastBellAt = 0;
     // drill-down mode: show a single session's full output
@@ -215,9 +234,9 @@ export class TUI {
     isActive() {
         return this.active;
     }
-    /** Return the current number of sessions (for mouse hit testing) */
+    /** Return the current number of visible sessions (for mouse hit testing) */
     getSessionCount() {
-        return this.sessions.length;
+        return this.getVisibleCount();
     }
     /** Set the session sort mode and repaint. */
     setSortMode(mode) {
@@ -240,7 +259,7 @@ export class TUI {
             return;
         this.compactMode = enabled;
         if (this.active) {
-            this.computeLayout(this.sessions.length);
+            this.computeLayout(this.getVisibleCount());
             this.paintAll();
         }
     }
@@ -285,6 +304,31 @@ export class TUI {
     getPinnedCount() {
         return this.pinnedIds.size;
     }
+    /** Enable or disable focus mode. When focused, only pinned sessions are visible. */
+    setFocus(enabled) {
+        if (enabled === this.focusMode)
+            return;
+        this.focusMode = enabled;
+        if (this.active) {
+            this.computeLayout(this.getVisibleCount());
+            this.paintAll();
+        }
+    }
+    /** Return whether focus mode is enabled. */
+    isFocused() {
+        return this.focusMode;
+    }
+    /** Return count of visible sessions (all in normal mode, pinned-only in focus mode). */
+    getVisibleCount() {
+        if (!this.focusMode)
+            return this.sessions.length;
+        let count = 0;
+        for (const s of this.sessions) {
+            if (this.pinnedIds.has(s.id))
+                count++;
+        }
+        return count;
+    }
     /** Enable or disable terminal bell notifications. */
     setBell(enabled) {
         this.bellEnabled = enabled;
@@ -293,6 +337,55 @@ export class TUI {
     isBellEnabled() {
         return this.bellEnabled;
     }
+    /**
+     * Add a bookmark at the current activity position.
+     * Returns the bookmark number (1-indexed) or 0 if buffer is empty.
+     */
+    addBookmark() {
+        if (this.activityBuffer.length === 0)
+            return 0;
+        // bookmark the entry at the current view position
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        const { start } = computeScrollSlice(this.activityBuffer.length, visibleLines, this.scrollOffset);
+        const entry = this.activityBuffer[start];
+        if (!entry)
+            return 0;
+        const bm = { index: start, label: `${entry.time} ${entry.tag}` };
+        this.bookmarks.push(bm);
+        if (this.bookmarks.length > MAX_BOOKMARKS) {
+            this.bookmarks = this.bookmarks.slice(-MAX_BOOKMARKS);
+        }
+        return this.bookmarks.length;
+    }
+    /**
+     * Jump to a bookmark by number (1-indexed). Returns false if not found.
+     * Adjusts scroll offset to center the bookmarked entry.
+     */
+    jumpToBookmark(num) {
+        const bm = this.bookmarks[num - 1];
+        if (!bm)
+            return false;
+        // clamp index to current buffer
+        if (bm.index >= this.activityBuffer.length)
+            return false;
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        this.scrollOffset = computeBookmarkOffset(bm.index, this.activityBuffer.length, visibleLines);
+        if (this.scrollOffset === 0)
+            this.newWhileScrolled = 0;
+        if (this.active && this.viewMode === "overview") {
+            this.repaintActivityRegion();
+            this.paintSeparator();
+        }
+        return true;
+    }
+    /** Return all bookmarks (for /marks listing). */
+    getBookmarks() {
+        return this.bookmarks;
+    }
+    /** Return bookmark count. */
+    getBookmarkCount() {
+        return this.bookmarks.length;
+    }
     // ── State updates ───────────────────────────────────────────────────────
     updateState(opts) {
         if (opts.phase !== undefined)
@@ -319,10 +412,11 @@ export class TUI {
                     this.prevLastActivity.set(s.id, s.lastActivity);
             }
             const sorted = sortSessions(opts.sessions, this.sortMode, this.lastChangeAt, this.pinnedIds);
-            const sessionCountChanged = sorted.length !== this.sessions.length;
+            const prevVisibleCount = this.getVisibleCount();
             this.sessions = sorted;
-            if (sessionCountChanged) {
-                this.computeLayout(this.sessions.length);
+            const newVisibleCount = this.getVisibleCount();
+            if (newVisibleCount !== prevVisibleCount) {
+                this.computeLayout(newVisibleCount);
                 this.paintAll();
                 return;
             }
@@ -516,7 +610,7 @@ export class TUI {
         this.drilldownNewWhileScrolled = 0;
         this.hoverSessionIdx = null;
         if (this.active) {
-            this.computeLayout(this.sessions.length);
+            this.computeLayout(this.getVisibleCount());
             this.paintAll();
         }
         return true;
@@ -531,7 +625,7 @@ export class TUI {
         this.drilldownNewWhileScrolled = 0;
         this.hoverSessionIdx = null;
         if (this.active) {
-            this.computeLayout(this.sessions.length);
+            this.computeLayout(this.getVisibleCount());
             this.paintAll();
         }
     }
@@ -594,8 +688,9 @@ export class TUI {
         }
         else {
             // overview: header (1) + sessions box + separator + activity + input
+            const visibleSessions = this.sessions.slice(0, this.getVisibleCount());
             const sessBodyRows = this.compactMode
-                ? computeCompactRowCount(this.sessions, this.cols - 2)
+                ? computeCompactRowCount(visibleSessions, this.cols - 2)
                 : Math.max(sessionCount, 1);
             this.sessionRows = sessBodyRows + 2; // + top/bottom borders
             this.separatorRow = this.headerHeight + this.sessionRows + 1;
@@ -608,7 +703,7 @@ export class TUI {
         }
     }
     onResize() {
-        this.computeLayout(this.sessions.length);
+        this.computeLayout(this.getVisibleCount());
         this.paintAll();
     }
     // ── Painting ────────────────────────────────────────────────────────────
@@ -636,7 +731,10 @@ export class TUI {
         }
         else {
             const phaseText = phaseDisplay(this.phase, this.paused, this.spinnerFrame);
-            const sessCount = `${this.sessions.length} agent${this.sessions.length !== 1 ? "s" : ""}`;
+            const visCount = this.getVisibleCount();
+            const sessCount = this.focusMode
+                ? `${visCount}/${this.sessions.length} agent${this.sessions.length !== 1 ? "s" : ""}`
+                : `${this.sessions.length} agent${this.sessions.length !== 1 ? "s" : ""}`;
             const activeCount = this.sessions.filter((s) => s.userActive).length;
             const activeTag = activeCount > 0 ? `  ${SLATE}│${RESET}  ${AMBER}${activeCount} user${RESET}` : "";
             // countdown to next tick (only in sleeping phase)
@@ -656,23 +754,29 @@ export class TUI {
     paintSessions() {
         const startRow = this.headerHeight + 1;
         const innerWidth = this.cols - 2; // inside the box borders
-        // top border with label (includes compact/sort mode tags)
+        const visibleCount = this.getVisibleCount();
+        const visibleSessions = this.sessions.slice(0, visibleCount); // pinned sort to top
+        // top border with label (includes focus/compact/sort mode tags)
+        const focusTag = this.focusMode ? "focus" : "";
         const sortTag = this.sortMode !== "default" ? this.sortMode : "";
         const compactTag = this.compactMode ? "compact" : "";
-        const tags = [compactTag, sortTag].filter(Boolean).join(", ");
+        const tags = [focusTag, compactTag, sortTag].filter(Boolean).join(", ");
         const label = tags ? ` agents (${tags}) ` : " agents ";
         const borderAfterLabel = Math.max(0, innerWidth - label.length);
         const topBorder = `${SLATE}${BOX.rtl}${BOX.h}${RESET}${SLATE}${label}${RESET}${SLATE}${BOX.h.repeat(borderAfterLabel)}${BOX.rtr}${RESET}`;
         process.stderr.write(SAVE_CURSOR + moveTo(startRow, 1) + CLEAR_LINE + truncateAnsi(topBorder, this.cols));
-        if (this.sessions.length === 0) {
+        if (visibleSessions.length === 0) {
             // empty state
-            const empty = `${SLATE}${BOX.v}${RESET}  ${DIM}no agents connected${RESET}`;
+            const msg = this.focusMode && this.sessions.length > 0
+                ? `${DIM}no pinned agents — /pin to add, /focus to exit${RESET}`
+                : `${DIM}no agents connected${RESET}`;
+            const empty = `${SLATE}${BOX.v}${RESET}  ${msg}`;
             const padded = padBoxLine(empty, this.cols);
             process.stderr.write(moveTo(startRow + 1, 1) + CLEAR_LINE + padded);
         }
         else if (this.compactMode) {
             // compact: inline tokens, multiple per row (with pin indicators)
-            const compactRows = formatCompactRows(this.sessions, innerWidth - 1, this.pinnedIds);
+            const compactRows = formatCompactRows(visibleSessions, innerWidth - 1, this.pinnedIds);
             for (let r = 0; r < compactRows.length; r++) {
                 const line = `${SLATE}${BOX.v}${RESET} ${compactRows[r]}`;
                 const padded = padBoxLine(line, this.cols);
@@ -680,8 +784,8 @@ export class TUI {
             }
         }
         else {
-            for (let i = 0; i < this.sessions.length; i++) {
-                const s = this.sessions[i];
+            for (let i = 0; i < visibleSessions.length; i++) {
+                const s = visibleSessions[i];
                 const isHovered = this.hoverSessionIdx === i + 1; // 1-indexed
                 const bg = isHovered ? BG_HOVER : "";
                 const pinned = this.pinnedIds.has(s.id);
@@ -694,8 +798,8 @@ export class TUI {
         }
         // bottom border
         const bodyRows = this.compactMode
-            ? computeCompactRowCount(this.sessions, innerWidth)
-            : Math.max(this.sessions.length, 1);
+            ? computeCompactRowCount(visibleSessions, innerWidth)
+            : Math.max(visibleCount, 1);
         const bottomRow = startRow + 1 + bodyRows;
         const bottomBorder = `${SLATE}${BOX.rbl}${BOX.h.repeat(Math.max(0, this.cols - 2))}${BOX.rbr}${RESET}`;
         process.stderr.write(moveTo(bottomRow, 1) + CLEAR_LINE + truncateAnsi(bottomBorder, this.cols));

package/package.json

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