aoaoe 0.70.0 → 0.72.0

package/dist/config.d.ts

@@ -46,6 +46,9 @@ export declare function parseCliArgs(argv: string[]): {
     tailCount?: number;
     runStats: boolean;
     statsLast?: string;
+    runReplay: boolean;
+    replaySpeed?: number;
+    replayLast?: string;
     registerTitle?: string;
 };
 export declare function printHelp(): void;

package/dist/config.js

@@ -327,7 +327,7 @@ export function parseCliArgs(argv) {
     let initForce = false;
     let runTaskCli = false;
     let registerTitle;
-    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined };
+    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -419,6 +419,24 @@ export function parseCliArgs(argv) {
         }
         return { ...defaults, runStats: true, statsLast: last };
     }
+    if (argv[2] === "replay") {
+        let speed;
+        let last;
+        for (let i = 3; i < argv.length; i++) {
+            if ((argv[i] === "--speed" || argv[i] === "-s") && argv[i + 1]) {
+                const val = parseFloat(argv[++i]);
+                if (!isNaN(val) && val >= 0)
+                    speed = val;
+            }
+            else if ((argv[i] === "--last" || argv[i] === "-l") && argv[i + 1]) {
+                last = argv[++i];
+            }
+            else if (argv[i] === "--instant") {
+                speed = 0;
+            }
+        }
+        return { ...defaults, runReplay: true, replaySpeed: speed, replayLast: last };
+    }
     if (argv[2] === "register") {
         register = true;
         // parse --title from remaining args
@@ -512,7 +530,7 @@ export function parseCliArgs(argv) {
                 break;
         }
     }
-    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined };
+    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined };
 }
 export function printHelp() {
     console.log(`aoaoe - autonomous supervisor for agent-of-empires sessions
@@ -544,6 +562,10 @@ commands:
   export --last <duration>         time window: 1h, 6h, 24h, 7d (default: 24h)
   stats          show aggregate daemon statistics (actions, sessions, activity)
   stats --last <duration>  time window: 1h, 6h, 24h, 7d (default: all time)
+  replay         play back tui-history.jsonl like a movie with simulated timing
+  replay --speed <N>  playback speed: 1=realtime, 5=5x (default), 10=fast, 0=instant
+  replay --instant    same as --speed 0 (no delays, dump all entries immediately)
+  replay --last <duration>  only replay entries from the last 1h, 6h, 24h, 7d
   tail           live-stream daemon activity to a separate terminal
   tail -f        follow mode — keep watching for new entries (Ctrl+C to stop)
   tail -n <N>    number of entries to show (default: 50)
@@ -579,6 +601,11 @@ logs options:
   --grep, -g <pattern>               filter entries by substring or regex
   -n, --count <number>               number of entries to show (default: 50)
 
+replay options:
+  --speed, -s <number>               playback speed multiplier (default: 5)
+  --instant                          no delays, dump all entries immediately
+  --last, -l <duration>              time window: 1h, 6h, 24h, 7d
+
 tail options:
   -f, --follow                       keep watching for new entries (Ctrl+C to stop)
   -n, --count <number>               number of entries to show (default: 50)

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";
@@ -32,7 +32,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const AOAOE_DIR = join(homedir(), ".aoaoe"); // watch dir for wakeable sleep
 const INPUT_FILE = join(AOAOE_DIR, "pending-input.txt"); // file IPC from chat.ts
 async function main() {
-    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, configValidate, configDiff, notifyTest, runDoctor, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, configValidate, configDiff, notifyTest, runDoctor, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, runReplay: isReplay, replaySpeed, replayLast, registerTitle } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -115,6 +115,12 @@ async function main() {
         await runStatsCommand(statsLast);
         return;
     }
+    // `aoaoe replay` -- play back tui-history.jsonl like a movie
+    if (isReplay) {
+        const { runReplay: doReplay } = await import("./replay.js");
+        await doReplay({ speed: replaySpeed ?? 5, last: replayLast });
+        return;
+    }
     // `aoaoe task` -- task management CLI
     if (isTaskCli) {
         await runTaskCli(process.argv);
@@ -287,6 +293,21 @@ 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}`);
+            }
+        });
     }
     // start TUI (alternate screen buffer) after input is ready
     if (tui) {

package/dist/input.d.ts

@@ -1,6 +1,15 @@
 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;
+/** 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 +18,12 @@ export declare class InputReader {
     private scrollHandler;
     private queueChangeHandler;
     private viewHandler;
+    private mouseClickHandler;
+    private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
     onQueueChange(handler: (count: number) => void): void;
     onView(handler: ViewHandler): void;
+    onMouseClick(handler: MouseClickHandler): 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,8 @@ export class InputReader {
     scrollHandler = null;
     queueChangeHandler = null;
     viewHandler = null;
+    mouseClickHandler = null;
+    mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
     onScroll(handler) {
         this.scrollHandler = handler;
@@ -27,6 +43,10 @@ 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;
+    }
     notifyQueueChange() {
         this.queueChangeHandler?.(this.queue.length);
     }
@@ -44,6 +64,15 @@ 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 && evt.press && evt.button === 0 && this.mouseClickHandler) {
+                this.mouseClickHandler(evt.row, evt.col);
+            }
+        };
+        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 +131,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,6 +200,7 @@ ${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
+  click session      click an agent card to drill down (click again to go back)
   PgUp / PgDn        scroll through activity history
   Home / End         jump to oldest / return to live
 

package/dist/replay.d.ts

@@ -0,0 +1,43 @@
+import { type HistoryEntry } from "./tui-history.js";
+/**
+ * Compute the delay between two entries, scaled by speed multiplier.
+ * Caps individual delays to prevent long waits on idle periods.
+ */
+export declare function computeDelay(prevTs: number, currTs: number, speed: number, maxDelayMs?: number): number;
+/**
+ * Format a speed multiplier for display.
+ */
+export declare function formatSpeed(speed: number): string;
+/**
+ * Parse a speed string ("2x", "10x", "0.5x", "instant") into a number.
+ * Returns 0 for instant, null for invalid.
+ */
+export declare function parseSpeed(input: string): number | null;
+/**
+ * Filter entries by time window.
+ */
+export declare function filterByWindow(entries: HistoryEntry[], maxAgeMs?: number, now?: number): HistoryEntry[];
+/**
+ * Build the replay header.
+ */
+export declare function formatReplayHeader(entries: HistoryEntry[], speed: number, windowLabel?: string): string;
+/**
+ * Build the replay footer.
+ */
+export declare function formatReplayFooter(entries: HistoryEntry[]): string;
+/**
+ * Load entries from the history file, optionally filtering by time window.
+ */
+export declare function loadReplayEntries(maxAgeMs?: number, filePath?: string): HistoryEntry[];
+/**
+ * Run the replay.
+ * Prints entries with simulated delays between them.
+ * Speed 0 = instant (no delays).
+ * Ctrl+C stops playback.
+ */
+export declare function runReplay(opts: {
+    speed: number;
+    last?: string;
+    filePath?: string;
+}): Promise<void>;
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay.js

@@ -0,0 +1,174 @@
+// replay.ts — play back tui-history.jsonl like a movie.
+// shows what the daemon did with simulated timing or instant output.
+// reuses formatTailEntry from tail.ts for consistent rendering.
+// pure exported functions for testability.
+import { readFileSync, existsSync } from "node:fs";
+import { TUI_HISTORY_FILE } from "./tui-history.js";
+import { formatTailEntry, formatTailDate } from "./tail.js";
+import { parseDuration } from "./export.js";
+import { DIM, RESET, AMBER } from "./colors.js";
+/**
+ * Compute the delay between two entries, scaled by speed multiplier.
+ * Caps individual delays to prevent long waits on idle periods.
+ */
+export function computeDelay(prevTs, currTs, speed, maxDelayMs = 3000) {
+    if (speed <= 0)
+        return 0;
+    const raw = currTs - prevTs;
+    if (raw <= 0)
+        return 0;
+    return Math.min(Math.round(raw / speed), maxDelayMs);
+}
+/**
+ * Format a speed multiplier for display.
+ */
+export function formatSpeed(speed) {
+    if (speed <= 0)
+        return "instant";
+    if (speed === 1)
+        return "1x (realtime)";
+    if (Number.isInteger(speed))
+        return `${speed}x`;
+    return `${speed.toFixed(1)}x`;
+}
+/**
+ * Parse a speed string ("2x", "10x", "0.5x", "instant") into a number.
+ * Returns 0 for instant, null for invalid.
+ */
+export function parseSpeed(input) {
+    if (input === "instant" || input === "0")
+        return 0;
+    const match = input.match(/^(\d+(?:\.\d+)?)x?$/);
+    if (!match)
+        return null;
+    const val = parseFloat(match[1]);
+    if (!isFinite(val) || val < 0)
+        return null;
+    return val;
+}
+/**
+ * Filter entries by time window.
+ */
+export function filterByWindow(entries, maxAgeMs, now) {
+    if (!maxAgeMs)
+        return entries;
+    const cutoff = (now ?? Date.now()) - maxAgeMs;
+    return entries.filter((e) => e.ts >= cutoff);
+}
+/**
+ * Build the replay header.
+ */
+export function formatReplayHeader(entries, speed, windowLabel) {
+    if (entries.length === 0)
+        return `${DIM}no entries to replay${RESET}`;
+    const first = entries[0];
+    const last = entries[entries.length - 1];
+    const dateRange = formatTailDate(first.ts) === formatTailDate(last.ts)
+        ? formatTailDate(first.ts)
+        : `${formatTailDate(first.ts)} → ${formatTailDate(last.ts)}`;
+    const span = last.ts - first.ts;
+    const spanStr = span < 60_000 ? `${Math.floor(span / 1000)}s`
+        : span < 3_600_000 ? `${Math.floor(span / 60_000)}m`
+            : `${Math.floor(span / 3_600_000)}h ${Math.floor((span % 3_600_000) / 60_000)}m`;
+    const speedStr = formatSpeed(speed);
+    const windowStr = windowLabel ? ` (${windowLabel})` : "";
+    return `${DIM}── replay: ${entries.length} entries, ${dateRange}, span ${spanStr}, ${AMBER}${speedStr}${RESET}${DIM}${windowStr} ──${RESET}`;
+}
+/**
+ * Build the replay footer.
+ */
+export function formatReplayFooter(entries) {
+    if (entries.length === 0)
+        return "";
+    return `${DIM}── replay complete: ${entries.length} entries ──${RESET}`;
+}
+/**
+ * Sleep for a given number of milliseconds.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Load entries from the history file, optionally filtering by time window.
+ */
+export function loadReplayEntries(maxAgeMs, filePath = TUI_HISTORY_FILE) {
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isValidEntry(parsed))
+                    entries.push(parsed);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        return filterByWindow(entries, maxAgeMs);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Run the replay.
+ * Prints entries with simulated delays between them.
+ * Speed 0 = instant (no delays).
+ * Ctrl+C stops playback.
+ */
+export async function runReplay(opts) {
+    const filePath = opts.filePath ?? TUI_HISTORY_FILE;
+    const maxAgeMs = opts.last ? parseDuration(opts.last) ?? undefined : undefined;
+    if (opts.last && maxAgeMs === undefined) {
+        process.stderr.write(`error: --last must be like "1h", "6h", "24h", "7d", got "${opts.last}"\n`);
+        process.exit(1);
+    }
+    const entries = loadReplayEntries(maxAgeMs, filePath);
+    const windowLabel = opts.last ?? undefined;
+    // header
+    process.stderr.write(formatReplayHeader(entries, opts.speed, windowLabel) + "\n");
+    if (entries.length === 0)
+        return;
+    // Ctrl+C cleanup
+    let stopped = false;
+    const onSignal = () => { stopped = true; };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        for (let i = 0; i < entries.length; i++) {
+            if (stopped)
+                break;
+            // delay between entries
+            if (i > 0 && opts.speed > 0) {
+                const delay = computeDelay(entries[i - 1].ts, entries[i].ts, opts.speed);
+                if (delay > 0)
+                    await sleep(delay);
+            }
+            if (stopped)
+                break;
+            process.stderr.write(formatTailEntry(entries[i]) + "\n");
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+    }
+    // footer
+    if (!stopped) {
+        process.stderr.write(formatReplayFooter(entries) + "\n");
+    }
+}
+function isValidEntry(val) {
+    if (typeof val !== "object" || val === null)
+        return false;
+    const obj = val;
+    return (typeof obj.ts === "number" &&
+        typeof obj.time === "string" &&
+        typeof obj.tag === "string" &&
+        typeof obj.text === "string");
+}
+//# sourceMappingURL=replay.js.map

package/dist/tui.d.ts

@@ -36,6 +36,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;
@@ -94,5 +96,13 @@ declare function computeScrollSlice(bufferLen: number, visibleLines: number, scr
     end: number;
 };
 declare function formatScrollIndicator(offset: number, totalEntries: 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, 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`;
@@ -76,8 +79,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 +105,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)
@@ -383,7 +390,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);
@@ -639,6 +646,23 @@ function formatScrollIndicator(offset, totalEntries, visibleLines, newCount) {
     const newTag = newCount > 0 ? `  ${newCount} new ↓` : "";
     return ` ↑ ${offset} older  │  ${position}/${totalEntries}  │  PgUp/PgDn  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 };
 //# sourceMappingURL=tui.js.map

package/package.json

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