aoaoe 0.63.0 → 0.65.0

package/README.md

@@ -248,6 +248,10 @@ commands:
   logs --actions show action log entries (from ~/.aoaoe/actions.log)
   logs --grep <pattern>  filter log entries by substring or regex
   logs -n <count>        number of entries to show (default: 50)
+  export         export session timeline as JSON or Markdown for post-mortems
+  export --format <json|markdown>  output format (default: json)
+  export --output <file>           write to file (default: stdout)
+  export --last <duration>         time window: 1h, 6h, 24h, 7d (default: 24h)
   task           manage tasks and sessions (list, start, stop, new, rm, edit)
   tasks          show task progress (from aoaoe.tasks.json)
   history        review recent actions (from ~/.aoaoe/actions.log)

package/dist/config.d.ts

@@ -34,6 +34,10 @@ export declare function parseCliArgs(argv: string[]): {
     logsActions: boolean;
     logsGrep?: string;
     logsCount?: number;
+    runExport: boolean;
+    exportFormat?: string;
+    exportOutput?: string;
+    exportLast?: string;
     runInit: boolean;
     initForce: boolean;
     runTaskCli: boolean;

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, runInit: false, initForce: false, runTaskCli: false };
+    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 };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -374,6 +374,23 @@ export function parseCliArgs(argv) {
         }
         return { ...defaults, runLogs: true, logsActions: actions, logsGrep: grep, logsCount: count };
     }
+    if (argv[2] === "export") {
+        let format;
+        let output;
+        let last;
+        for (let i = 3; i < argv.length; i++) {
+            if ((argv[i] === "--format" || argv[i] === "-f") && argv[i + 1]) {
+                format = argv[++i];
+            }
+            else if ((argv[i] === "--output" || argv[i] === "-o") && argv[i + 1]) {
+                output = argv[++i];
+            }
+            else if ((argv[i] === "--last" || argv[i] === "-l") && argv[i + 1]) {
+                last = argv[++i];
+            }
+        }
+        return { ...defaults, runExport: true, exportFormat: format, exportOutput: output, exportLast: last };
+    }
     if (argv[2] === "init") {
         const force = argv.includes("--force") || argv.includes("-f");
         return { ...defaults, runInit: true, initForce: force };
@@ -471,7 +488,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, runInit: false, initForce: false, runTaskCli: false };
+    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 };
 }
 export function printHelp() {
     console.log(`aoaoe - autonomous supervisor for agent-of-empires sessions
@@ -497,6 +514,10 @@ commands:
   logs --actions show action log entries (from ~/.aoaoe/actions.log)
   logs --grep <pattern>  filter log entries by substring or regex
   logs -n <count>        number of entries to show (default: 50)
+  export         export session timeline as JSON or Markdown for post-mortems
+  export --format <json|markdown>  output format (default: json)
+  export --output <file>           write to file (default: stdout)
+  export --last <duration>         time window: 1h, 6h, 24h, 7d (default: 24h)
   task           manage tasks and sessions (list, start, stop, new, rm, edit)
   tasks          show task progress (from aoaoe.tasks.json)
   history        review recent actions (from ~/.aoaoe/actions.log)

package/dist/export.d.ts

@@ -0,0 +1,17 @@
+import type { HistoryEntry } from "./tui-history.js";
+export interface TimelineEntry {
+    ts: number;
+    source: "action" | "activity";
+    tag: string;
+    text: string;
+    success?: boolean;
+    session?: string;
+}
+export declare function parseActionLogEntries(lines: string[]): TimelineEntry[];
+export declare function parseActivityEntries(entries: HistoryEntry[]): TimelineEntry[];
+export declare function mergeTimeline(...sources: TimelineEntry[][]): TimelineEntry[];
+export declare function filterByAge(entries: TimelineEntry[], maxAgeMs: number, now?: number): TimelineEntry[];
+export declare function parseDuration(input: string): number | null;
+export declare function formatTimelineJson(entries: TimelineEntry[]): string;
+export declare function formatTimelineMarkdown(entries: TimelineEntry[]): string;
+//# sourceMappingURL=export.d.ts.map

package/dist/export.js

@@ -0,0 +1,132 @@
+// export.ts — pure functions for exporting session timelines as JSON or Markdown
+// reads actions.log (JSONL) and tui-history.jsonl, merges into a unified timeline
+import { toActionLogEntry } from "./types.js";
+// ── parsers ─────────────────────────────────────────────────────────────────
+// parse actions.log JSONL lines into timeline entries
+export function parseActionLogEntries(lines) {
+    const entries = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = toActionLogEntry(JSON.parse(line));
+            if (!entry)
+                continue;
+            // skip wait actions (noise in post-mortems)
+            if (entry.action.action === "wait")
+                continue;
+            entries.push({
+                ts: entry.timestamp,
+                source: "action",
+                tag: entry.action.action,
+                text: entry.detail || `${entry.action.action} on ${entry.action.session ?? "unknown"}`,
+                success: entry.success,
+                session: entry.action.session ?? entry.action.title,
+            });
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return entries;
+}
+// convert tui-history entries into timeline entries
+export function parseActivityEntries(entries) {
+    return entries.map((e) => ({
+        ts: e.ts,
+        source: "activity",
+        tag: e.tag,
+        text: e.text,
+    }));
+}
+// ── merge + filter ──────────────────────────────────────────────────────────
+// merge multiple sources into a single chronological timeline
+export function mergeTimeline(...sources) {
+    const all = sources.flat();
+    all.sort((a, b) => a.ts - b.ts);
+    return all;
+}
+// filter entries by time window (keep entries newer than cutoff)
+export function filterByAge(entries, maxAgeMs, now = Date.now()) {
+    const cutoff = now - maxAgeMs;
+    return entries.filter((e) => e.ts >= cutoff);
+}
+// ── duration parser ─────────────────────────────────────────────────────────
+// parse human-friendly duration strings: "1h", "6h", "24h", "2d", "7d", "30d"
+export function parseDuration(input) {
+    const match = input.match(/^(\d+)(h|d)$/);
+    if (!match)
+        return null;
+    const val = parseInt(match[1], 10);
+    if (val <= 0)
+        return null;
+    const unit = match[2];
+    if (unit === "h")
+        return val * 60 * 60 * 1000;
+    if (unit === "d")
+        return val * 24 * 60 * 60 * 1000;
+    return null;
+}
+// ── formatters ──────────────────────────────────────────────────────────────
+// format timeline as pretty-printed JSON
+export function formatTimelineJson(entries) {
+    const output = entries.map((e) => {
+        const obj = {
+            time: new Date(e.ts).toISOString(),
+            source: e.source,
+            tag: e.tag,
+            text: e.text,
+        };
+        if (e.success !== undefined)
+            obj.success = e.success;
+        if (e.session)
+            obj.session = e.session;
+        return obj;
+    });
+    return JSON.stringify(output, null, 2) + "\n";
+}
+// format timeline as a readable Markdown post-mortem document
+export function formatTimelineMarkdown(entries) {
+    if (entries.length === 0) {
+        return "# aoaoe Session Export\n\n_No entries in the selected time range._\n";
+    }
+    const lines = [];
+    const now = new Date();
+    const first = new Date(entries[0].ts);
+    const last = new Date(entries[entries.length - 1].ts);
+    lines.push("# aoaoe Session Export");
+    lines.push("");
+    lines.push(`**Generated**: ${now.toISOString()}`);
+    lines.push(`**Range**: ${first.toISOString()} — ${last.toISOString()}`);
+    lines.push(`**Entries**: ${entries.length}`);
+    lines.push("");
+    lines.push("## Timeline");
+    lines.push("");
+    // group entries by hour
+    let currentHour = "";
+    for (const entry of entries) {
+        const d = new Date(entry.ts);
+        const hour = d.toLocaleString("en-US", {
+            month: "short", day: "numeric", hour: "numeric", minute: undefined, hour12: true,
+        }).replace(/:00/, "");
+        // simpler: just use HH:00 block headers
+        const hourKey = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")} ${String(d.getHours()).padStart(2, "0")}:00`;
+        if (hourKey !== currentHour) {
+            if (currentHour)
+                lines.push("");
+            lines.push(`### ${hourKey}`);
+            lines.push("");
+            currentHour = hourKey;
+        }
+        const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+        const icon = entry.source === "action"
+            ? (entry.success ? "+" : "!")
+            : "·";
+        const sessionPart = entry.session ? ` → ${entry.session}` : "";
+        const text = entry.text.length > 120 ? entry.text.slice(0, 117) + "..." : entry.text;
+        lines.push(`- \`${time}\` ${icon} **${entry.tag}**${sessionPart}: ${text}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+//# sourceMappingURL=export.js.map

package/dist/index.js

@@ -20,6 +20,7 @@ import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
 import { loadTuiHistory } from "./tui-history.js";
+import { parseActionLogEntries, parseActivityEntries, mergeTimeline, filterByAge, parseDuration, formatTimelineJson, formatTimelineMarkdown } from "./export.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
 import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync, chmodSync } from "node:fs";
@@ -30,7 +31,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, runInit, initForce, runTaskCli: isTaskCli, 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, registerTitle } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -103,6 +104,11 @@ async function main() {
         await showLogs(logsActions, logsGrep, logsCount);
         return;
     }
+    // `aoaoe export` -- export session timeline as JSON or Markdown
+    if (runExport) {
+        await runTimelineExport(exportFormat, exportOutput, exportLast);
+        return;
+    }
     // `aoaoe task` -- task management CLI
     if (isTaskCli) {
         await runTaskCli(process.argv);
@@ -229,6 +235,25 @@ async function main() {
     // start interactive input listener and conversation log
     input.start();
     await reasonerConsole.start();
+    // 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;
+            }
+        });
+    }
     // start TUI (alternate screen buffer) after input is ready
     if (tui) {
         // replay persisted history from previous runs before entering alt screen
@@ -1311,6 +1336,47 @@ async function showLogs(actions, grep, count) {
         console.log("");
     }
 }
+// `aoaoe export` -- export session timeline as JSON or Markdown for post-mortems
+async function runTimelineExport(format, output, last) {
+    const fmt = format ?? "json";
+    if (fmt !== "json" && fmt !== "markdown" && fmt !== "md") {
+        console.error(`error: --format must be "json" or "markdown", got "${fmt}"`);
+        process.exit(1);
+    }
+    // parse time window (default 24h)
+    const durationMs = last ? parseDuration(last) : 24 * 60 * 60 * 1000;
+    if (durationMs === null) {
+        console.error(`error: --last must be like "1h", "6h", "24h", "7d", got "${last}"`);
+        process.exit(1);
+    }
+    // read actions.log
+    const actionsFile = join(homedir(), ".aoaoe", "actions.log");
+    let actionEntries = [];
+    try {
+        const lines = readFileSync(actionsFile, "utf-8").trim().split("\n").filter((l) => l.trim());
+        actionEntries = parseActionLogEntries(lines);
+    }
+    catch {
+        // no actions.log — that's fine
+    }
+    // read tui-history.jsonl
+    const historyEntries = loadTuiHistory(10_000, undefined, durationMs);
+    const activityEntries = parseActivityEntries(historyEntries);
+    // merge and filter
+    let timeline = mergeTimeline(actionEntries, activityEntries);
+    timeline = filterByAge(timeline, durationMs);
+    // format
+    const isMarkdown = fmt === "markdown" || fmt === "md";
+    const content = isMarkdown ? formatTimelineMarkdown(timeline) : formatTimelineJson(timeline);
+    // output
+    if (output) {
+        writeFileSync(output, content);
+        console.log(`exported ${timeline.length} entries to ${output}`);
+    }
+    else {
+        process.stdout.write(content);
+    }
+}
 // `aoaoe test` -- dynamically import and run the integration test
 async function runIntegrationTest() {
     const testModule = resolve(__dirname, "integration-test.js");

package/dist/input.d.ts

@@ -1,8 +1,11 @@
+export type ScrollDirection = "up" | "down" | "top" | "bottom";
 export declare class InputReader {
     private rl;
     private queue;
     private paused;
     private lastEscTime;
+    private scrollHandler;
+    onScroll(handler: (dir: ScrollDirection) => void): void;
     start(): void;
     drain(): string[];
     isPaused(): boolean;

package/dist/input.js

@@ -11,6 +11,11 @@ export class InputReader {
     queue = []; // pending user messages for the reasoner
     paused = false;
     lastEscTime = 0;
+    scrollHandler = null;
+    // register a callback for scroll key events (PgUp/PgDn/Home/End)
+    onScroll(handler) {
+        this.scrollHandler = handler;
+    }
     start() {
         // only works if stdin is a TTY (not piped)
         if (!process.stdin.isTTY)
@@ -39,6 +44,21 @@ export class InputReader {
             else {
                 this.lastEscTime = 0;
             }
+            // scroll key detection (PgUp, PgDn, Home, End)
+            if (this.scrollHandler) {
+                if (key?.name === "pageup" || key?.sequence === "\x1b[5~") {
+                    this.scrollHandler("up");
+                }
+                else if (key?.name === "pagedown" || key?.sequence === "\x1b[6~") {
+                    this.scrollHandler("down");
+                }
+                else if (key?.name === "home" || key?.sequence === "\x1b[1~") {
+                    this.scrollHandler("top");
+                }
+                else if (key?.name === "end" || key?.sequence === "\x1b[4~") {
+                    this.scrollHandler("bottom");
+                }
+            }
         });
         // show hint on startup
         console.error(`${DIM}type a message to talk to the AI supervisor, /help for commands, ESC ESC to interrupt${RESET}`);
@@ -105,6 +125,8 @@ ${BOLD}controls:${RESET}
   /resume            resume the supervisor
   /interrupt         interrupt the AI mid-thought
   ESC ESC            same as /interrupt (shortcut)
+  PgUp / PgDn        scroll through activity history
+  Home / End         jump to oldest / return to live
 
 ${BOLD}info:${RESET}
   /status            show daemon state

package/dist/tui.d.ts

@@ -20,6 +20,8 @@ export declare class TUI {
     private activityBuffer;
     private maxActivity;
     private spinnerFrame;
+    private scrollOffset;
+    private newWhileScrolled;
     private phase;
     private pollCount;
     private sessions;
@@ -40,6 +42,11 @@ export declare class TUI {
     }): void;
     log(tag: string, text: string): void;
     replayHistory(entries: HistoryEntry[]): void;
+    scrollUp(lines?: number): void;
+    scrollDown(lines?: number): void;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+    isScrolledBack(): boolean;
     private updateDimensions;
     private computeLayout;
     private onResize;
@@ -63,5 +70,10 @@ declare function truncatePlain(str: string, max: number): string;
  * Kept for backward compatibility — used by non-TUI output paths.
  */
 export declare function formatSessionSentence(s: DaemonSessionState, maxCols: number): string;
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay };
+declare function computeScrollSlice(bufferLen: number, visibleLines: number, scrollOffset: number): {
+    start: number;
+    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 };
 //# sourceMappingURL=tui.d.ts.map

package/dist/tui.js

@@ -55,6 +55,8 @@ export class TUI {
     activityBuffer = []; // ring buffer for activity log
     maxActivity = 500; // max entries to keep
     spinnerFrame = 0; // current spinner animation frame
+    scrollOffset = 0; // 0 = live (bottom), >0 = scrolled back N entries
+    newWhileScrolled = 0; // entries added while user is scrolled back
     // current state for repaints
     phase = "sleeping";
     pollCount = 0;
@@ -139,8 +141,16 @@ export class TUI {
         if (this.activityBuffer.length > this.maxActivity) {
             this.activityBuffer = this.activityBuffer.slice(-this.maxActivity);
         }
-        if (this.active)
-            this.writeActivityLine(entry);
+        if (this.active) {
+            if (this.scrollOffset > 0) {
+                // user is scrolled back — don't auto-scroll, just show indicator
+                this.newWhileScrolled++;
+                this.paintSeparator();
+            }
+            else {
+                this.writeActivityLine(entry);
+            }
+        }
         // persist to disk (fire-and-forget, never blocks)
         appendHistoryEntry({ ts: now.getTime(), time, tag, text });
     }
@@ -155,6 +165,48 @@ export class TUI {
             this.activityBuffer = this.activityBuffer.slice(-this.maxActivity);
         }
     }
+    // ── Scroll navigation ────────────────────────────────────────────────────
+    scrollUp(lines) {
+        if (!this.active)
+            return;
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        const n = lines ?? Math.max(1, Math.floor(visibleLines / 2));
+        const maxOffset = Math.max(0, this.activityBuffer.length - visibleLines);
+        this.scrollOffset = Math.min(maxOffset, this.scrollOffset + n);
+        this.repaintActivityRegion();
+        this.paintSeparator();
+    }
+    scrollDown(lines) {
+        if (!this.active)
+            return;
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        const n = lines ?? Math.max(1, Math.floor(visibleLines / 2));
+        const wasScrolled = this.scrollOffset > 0;
+        this.scrollOffset = Math.max(0, this.scrollOffset - n);
+        if (wasScrolled && this.scrollOffset === 0)
+            this.newWhileScrolled = 0;
+        this.repaintActivityRegion();
+        this.paintSeparator();
+    }
+    scrollToTop() {
+        if (!this.active)
+            return;
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        this.scrollOffset = Math.max(0, this.activityBuffer.length - visibleLines);
+        this.repaintActivityRegion();
+        this.paintSeparator();
+    }
+    scrollToBottom() {
+        if (!this.active)
+            return;
+        this.scrollOffset = 0;
+        this.newWhileScrolled = 0;
+        this.repaintActivityRegion();
+        this.paintSeparator();
+    }
+    isScrolledBack() {
+        return this.scrollOffset > 0;
+    }
     // ── Layout computation ──────────────────────────────────────────────────
     updateDimensions() {
         this.cols = process.stderr.columns || 80;
@@ -245,8 +297,14 @@ export class TUI {
         process.stderr.write(RESTORE_CURSOR);
     }
     paintSeparator() {
-        const hints = " esc esc: interrupt  /help  /explain  /pause ";
         const prefix = `${BOX.h}${BOX.h} activity `;
+        let hints;
+        if (this.scrollOffset > 0) {
+            hints = formatScrollIndicator(this.scrollOffset, this.activityBuffer.length, this.scrollBottom - this.scrollTop + 1, this.newWhileScrolled);
+        }
+        else {
+            hints = " esc esc: interrupt  /help  /explain  /pause ";
+        }
         const totalLen = prefix.length + hints.length;
         const fill = Math.max(0, this.cols - totalLen);
         const left = Math.floor(fill / 2);
@@ -265,7 +323,8 @@ export class TUI {
     }
     repaintActivityRegion() {
         const visibleLines = this.scrollBottom - this.scrollTop + 1;
-        const entries = this.activityBuffer.slice(-visibleLines);
+        const { start, end } = computeScrollSlice(this.activityBuffer.length, visibleLines, this.scrollOffset);
+        const entries = this.activityBuffer.slice(start, end);
         for (let i = 0; i < visibleLines; i++) {
             const row = this.scrollTop + i;
             if (i < entries.length) {
@@ -431,6 +490,19 @@ export function formatSessionSentence(s, maxCols) {
     }
     return truncateAnsi(`${dot} ${BOLD}${name}${RESET} ${tool} ${SLATE}—${RESET} ${statusDesc}`, maxCols);
 }
+// ── Scroll helpers (pure, exported for testing) ─────────────────────────────
+// compute the slice indices for the activity buffer given scroll state
+function computeScrollSlice(bufferLen, visibleLines, scrollOffset) {
+    const end = Math.max(0, bufferLen - scrollOffset);
+    const start = Math.max(0, end - visibleLines);
+    return { start, end };
+}
+// format the scroll indicator text for the separator bar
+function formatScrollIndicator(offset, totalEntries, visibleLines, newCount) {
+    const position = totalEntries - offset;
+    const newTag = newCount > 0 ? `  ${newCount} new ↓` : "";
+    return ` ↑ ${offset} older  │  ${position}/${totalEntries}  │  PgUp/PgDn  End=live${newTag} `;
+}
 // ── Exported pure helpers (for testing) ─────────────────────────────────────
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator };
 //# sourceMappingURL=tui.js.map

package/package.json

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