aoaoe 0.69.0 → 0.71.0

package/dist/config.d.ts

@@ -44,6 +44,11 @@ export declare function parseCliArgs(argv: string[]): {
     runTail: boolean;
     tailFollow: boolean;
     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 };
+    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 };
@@ -410,6 +410,33 @@ export function parseCliArgs(argv) {
         }
         return { ...defaults, runTail: true, tailFollow: follow, tailCount: count };
     }
+    if (argv[2] === "stats") {
+        let last;
+        for (let i = 3; i < argv.length; i++) {
+            if ((argv[i] === "--last" || argv[i] === "-l") && argv[i + 1]) {
+                last = argv[++i];
+            }
+        }
+        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
@@ -503,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 };
+    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
@@ -533,6 +560,12 @@ commands:
   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)
+  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)
@@ -568,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

@@ -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, 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);
@@ -110,6 +110,17 @@ async function main() {
         await runTimelineExport(exportFormat, exportOutput, exportLast);
         return;
     }
+    // `aoaoe stats` -- show aggregate daemon statistics
+    if (isStats) {
+        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);
@@ -1455,6 +1466,36 @@ async function runTimelineExport(format, output, last) {
         process.stdout.write(content);
     }
 }
+// `aoaoe stats` -- show aggregate daemon statistics
+async function runStatsCommand(last) {
+    const { parseActionStats, parseHistoryStats, combineStats, formatStats } = await import("./stats.js");
+    const { parseDuration } = await import("./export.js");
+    const { loadTuiHistory } = await import("./tui-history.js");
+    const maxAgeMs = last ? parseDuration(last) : undefined;
+    if (last && maxAgeMs === undefined) {
+        console.error(`error: --last must be like "1h", "6h", "24h", "7d", got "${last}"`);
+        process.exit(1);
+    }
+    const windowLabel = last ?? "all time";
+    // read actions.log
+    const actionsFile = join(homedir(), ".aoaoe", "actions.log");
+    let actionLines = [];
+    try {
+        if (existsSync(actionsFile)) {
+            actionLines = readFileSync(actionsFile, "utf-8").trim().split("\n").filter((l) => l.trim());
+        }
+    }
+    catch {
+        // no actions — that's fine
+    }
+    // read tui-history
+    const retentionMs = maxAgeMs ?? 365 * 24 * 60 * 60 * 1000; // 1 year default
+    const historyEntries = loadTuiHistory(100_000, undefined, retentionMs);
+    const actionStats = parseActionStats(actionLines, maxAgeMs ?? undefined);
+    const historyStats = parseHistoryStats(historyEntries, maxAgeMs ?? undefined);
+    const combined = combineStats(actionStats, historyStats);
+    console.log(formatStats(combined, windowLabel));
+}
 // `aoaoe test` -- dynamically import and run the integration test
 async function runIntegrationTest() {
     const testModule = resolve(__dirname, "integration-test.js");

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/stats.d.ts

@@ -0,0 +1,54 @@
+import type { HistoryEntry } from "./tui-history.js";
+export interface ActionStats {
+    total: number;
+    succeeded: number;
+    failed: number;
+    byType: Map<string, number>;
+    bySession: Map<string, {
+        total: number;
+        ok: number;
+        fail: number;
+    }>;
+    firstTs: number;
+    lastTs: number;
+}
+export interface HistoryStats {
+    total: number;
+    byTag: Map<string, number>;
+    firstTs: number;
+    lastTs: number;
+}
+export interface CombinedStats {
+    actions: ActionStats | null;
+    history: HistoryStats | null;
+    timeRange: {
+        start: number;
+        end: number;
+    } | null;
+}
+/**
+ * Parse action log lines into aggregate stats.
+ * Skips malformed lines and wait actions.
+ */
+export declare function parseActionStats(lines: string[], maxAgeMs?: number, now?: number): ActionStats | null;
+/**
+ * Parse tui-history entries into aggregate stats.
+ */
+export declare function parseHistoryStats(entries: HistoryEntry[], maxAgeMs?: number, now?: number): HistoryStats | null;
+/**
+ * Combine action and history stats into a unified stats object.
+ */
+export declare function combineStats(actions: ActionStats | null, history: HistoryStats | null): CombinedStats;
+/**
+ * Format a duration in ms as a human-friendly string.
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format a rate as "X per hour" or "X per day".
+ */
+export declare function formatRate(count: number, spanMs: number): string;
+/**
+ * Format the full stats display for terminal output.
+ */
+export declare function formatStats(stats: CombinedStats, windowLabel?: string): string;
+//# sourceMappingURL=stats.d.ts.map

package/dist/stats.js

@@ -0,0 +1,221 @@
+// stats.ts — aggregate daemon statistics from actions.log and tui-history.jsonl.
+// pure exported functions for testability.
+import { toActionLogEntry } from "./types.js";
+import { BOLD, RESET, DIM, GREEN, RED, YELLOW, SLATE, AMBER, LIME, SKY, CYAN, } from "./colors.js";
+// ── Parsing ───────────────────────────────────────────────────────────────────
+/**
+ * Parse action log lines into aggregate stats.
+ * Skips malformed lines and wait actions.
+ */
+export function parseActionStats(lines, maxAgeMs, now) {
+    const cutoff = maxAgeMs ? (now ?? Date.now()) - maxAgeMs : 0;
+    const byType = new Map();
+    const bySession = new Map();
+    let total = 0;
+    let succeeded = 0;
+    let failed = 0;
+    let firstTs = Infinity;
+    let lastTs = 0;
+    for (const line of lines) {
+        try {
+            const entry = toActionLogEntry(JSON.parse(line));
+            if (!entry)
+                continue;
+            if (entry.action.action === "wait")
+                continue;
+            if (entry.timestamp < cutoff)
+                continue;
+            total++;
+            if (entry.success)
+                succeeded++;
+            else
+                failed++;
+            if (entry.timestamp < firstTs)
+                firstTs = entry.timestamp;
+            if (entry.timestamp > lastTs)
+                lastTs = entry.timestamp;
+            const type = entry.action.action;
+            byType.set(type, (byType.get(type) ?? 0) + 1);
+            const session = entry.action.title ?? entry.action.session?.slice(0, 8) ?? "unknown";
+            const existing = bySession.get(session) ?? { total: 0, ok: 0, fail: 0 };
+            existing.total++;
+            if (entry.success)
+                existing.ok++;
+            else
+                existing.fail++;
+            bySession.set(session, existing);
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    if (total === 0)
+        return null;
+    return { total, succeeded, failed, byType, bySession, firstTs, lastTs };
+}
+/**
+ * Parse tui-history entries into aggregate stats.
+ */
+export function parseHistoryStats(entries, maxAgeMs, now) {
+    const cutoff = maxAgeMs ? (now ?? Date.now()) - maxAgeMs : 0;
+    const byTag = new Map();
+    let total = 0;
+    let firstTs = Infinity;
+    let lastTs = 0;
+    for (const entry of entries) {
+        if (entry.ts < cutoff)
+            continue;
+        total++;
+        if (entry.ts < firstTs)
+            firstTs = entry.ts;
+        if (entry.ts > lastTs)
+            lastTs = entry.ts;
+        byTag.set(entry.tag, (byTag.get(entry.tag) ?? 0) + 1);
+    }
+    if (total === 0)
+        return null;
+    return { total, byTag, firstTs, lastTs };
+}
+/**
+ * Combine action and history stats into a unified stats object.
+ */
+export function combineStats(actions, history) {
+    let start = Infinity;
+    let end = 0;
+    if (actions) {
+        if (actions.firstTs < start)
+            start = actions.firstTs;
+        if (actions.lastTs > end)
+            end = actions.lastTs;
+    }
+    if (history) {
+        if (history.firstTs < start)
+            start = history.firstTs;
+        if (history.lastTs > end)
+            end = history.lastTs;
+    }
+    const timeRange = start < Infinity && end > 0 ? { start, end } : null;
+    return { actions, history, timeRange };
+}
+// ── Formatting ────────────────────────────────────────────────────────────────
+/**
+ * Format a duration in ms as a human-friendly string.
+ */
+export function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.floor(ms / 1000)}s`;
+    if (ms < 3_600_000) {
+        const m = Math.floor(ms / 60_000);
+        const s = Math.floor((ms % 60_000) / 1000);
+        return s > 0 ? `${m}m ${s}s` : `${m}m`;
+    }
+    if (ms < 86_400_000) {
+        const h = Math.floor(ms / 3_600_000);
+        const m = Math.floor((ms % 3_600_000) / 60_000);
+        return m > 0 ? `${h}h ${m}m` : `${h}h`;
+    }
+    const d = Math.floor(ms / 86_400_000);
+    const h = Math.floor((ms % 86_400_000) / 3_600_000);
+    return h > 0 ? `${d}d ${h}h` : `${d}d`;
+}
+/**
+ * Format a rate as "X per hour" or "X per day".
+ */
+export function formatRate(count, spanMs) {
+    if (spanMs <= 0)
+        return `${count} total`;
+    const hours = spanMs / 3_600_000;
+    if (hours < 1)
+        return `${count} total`;
+    const perHour = count / hours;
+    if (perHour >= 1)
+        return `${perHour.toFixed(1)}/hr`;
+    const perDay = perHour * 24;
+    return `${perDay.toFixed(1)}/day`;
+}
+/**
+ * Format the full stats display for terminal output.
+ */
+export function formatStats(stats, windowLabel) {
+    const lines = [];
+    const hr = "─".repeat(54);
+    lines.push("");
+    lines.push(`  ${BOLD}aoaoe — stats${RESET}${windowLabel ? `  ${DIM}(${windowLabel})${RESET}` : ""}`);
+    lines.push(`  ${hr}`);
+    // time range
+    if (stats.timeRange) {
+        const { start, end } = stats.timeRange;
+        const span = end - start;
+        const startStr = new Date(start).toLocaleString();
+        const endStr = new Date(end).toLocaleString();
+        lines.push(`  ${DIM}from:${RESET}  ${startStr}`);
+        lines.push(`  ${DIM}to:${RESET}    ${endStr}`);
+        lines.push(`  ${DIM}span:${RESET}  ${formatDuration(span)}`);
+    }
+    else {
+        lines.push(`  ${DIM}no data found${RESET}`);
+        lines.push("");
+        return lines.join("\n");
+    }
+    // actions
+    if (stats.actions) {
+        const a = stats.actions;
+        const span = a.lastTs - a.firstTs;
+        const rate = formatRate(a.total, span);
+        lines.push("");
+        lines.push(`  ${BOLD}actions${RESET}  ${DIM}(${rate})${RESET}`);
+        const successRate = a.total > 0 ? Math.round((a.succeeded / a.total) * 100) : 0;
+        const successColor = successRate >= 90 ? GREEN : successRate >= 70 ? YELLOW : RED;
+        lines.push(`  total:    ${BOLD}${a.total}${RESET}  ${GREEN}${a.succeeded} ok${RESET}  ${a.failed > 0 ? `${RED}${a.failed} failed${RESET}` : `${DIM}0 failed${RESET}`}  ${successColor}(${successRate}%)${RESET}`);
+        // by type — sorted by count descending
+        const sorted = [...a.byType.entries()].sort((x, y) => y[1] - x[1]);
+        for (const [type, count] of sorted) {
+            const bar = "█".repeat(Math.min(20, Math.round((count / a.total) * 20)));
+            const pct = Math.round((count / a.total) * 100);
+            lines.push(`  ${AMBER}${type.padEnd(18)}${RESET} ${String(count).padStart(4)}  ${SLATE}${bar}${RESET} ${DIM}${pct}%${RESET}`);
+        }
+        // top sessions — sorted by total actions
+        if (a.bySession.size > 0) {
+            lines.push("");
+            lines.push(`  ${BOLD}top sessions${RESET}`);
+            const topSessions = [...a.bySession.entries()]
+                .sort((x, y) => y[1].total - x[1].total)
+                .slice(0, 8);
+            for (const [name, counts] of topSessions) {
+                const failTag = counts.fail > 0 ? `  ${RED}${counts.fail} fail${RESET}` : "";
+                lines.push(`  ${CYAN}${name.padEnd(20)}${RESET} ${String(counts.total).padStart(4)} actions  ${GREEN}${counts.ok} ok${RESET}${failTag}`);
+            }
+        }
+    }
+    else {
+        lines.push("");
+        lines.push(`  ${DIM}no actions recorded${RESET}`);
+    }
+    // history activity breakdown
+    if (stats.history) {
+        const h = stats.history;
+        lines.push("");
+        lines.push(`  ${BOLD}activity${RESET}  ${DIM}(${h.total} events)${RESET}`);
+        const tagOrder = ["observation", "reasoner", "explain", "+ action", "! action", "you", "system", "status"];
+        const tagColors = {
+            "observation": SLATE, "reasoner": SKY, "explain": CYAN,
+            "+ action": AMBER, "! action": RED, "action": AMBER, "error": RED,
+            "you": LIME, "system": SLATE, "status": SLATE,
+        };
+        // sort: known tags first in order, then unknown by count
+        const knownTags = tagOrder.filter((t) => h.byTag.has(t));
+        const unknownTags = [...h.byTag.keys()].filter((t) => !tagOrder.includes(t)).sort((a, b) => (h.byTag.get(b) ?? 0) - (h.byTag.get(a) ?? 0));
+        const allTags = [...knownTags, ...unknownTags];
+        for (const tag of allTags) {
+            const count = h.byTag.get(tag) ?? 0;
+            const color = tagColors[tag] ?? SLATE;
+            const bar = "█".repeat(Math.min(20, Math.round((count / h.total) * 20)));
+            const pct = Math.round((count / h.total) * 100);
+            lines.push(`  ${color}${tag.padEnd(18)}${RESET} ${String(count).padStart(4)}  ${SLATE}${bar}${RESET} ${DIM}${pct}%${RESET}`);
+        }
+    }
+    lines.push(`  ${hr}`);
+    lines.push("");
+    return lines.join("\n");
+}
+//# sourceMappingURL=stats.js.map

package/package.json

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