aoaoe 0.114.0 → 0.122.0

package/dist/index.js

@@ -16,11 +16,11 @@ import { wakeableSleep } from "./wake.js";
 import { classifyMessages, formatUserMessages, buildReceipts, shouldSkipSleep, hasPendingFile, isInsistMessage, stripInsistPrefix } from "./message.js";
 import { TaskManager, loadTaskDefinitions, loadTaskState, formatTaskTable, importAoeSessionsToTasks } from "./task-manager.js";
 import { runTaskCli, handleTaskSlashCommand, quickTaskUpdate } from "./task-cli.js";
-import { TUI, hitTestSession, nextSortMode, SORT_MODES, formatUptime, formatClipText, loadTuiPrefs, saveTuiPrefs, validateGroupName, CONTEXT_BURN_THRESHOLD, buildSnapshotData, formatSnapshotJson, formatSnapshotMarkdown, formatBroadcastSummary, rankSessions, TOP_SORT_MODES, formatIdleSince, CONTEXT_CEILING_THRESHOLD } from "./tui.js";
+import { TUI, hitTestSession, nextSortMode, SORT_MODES, formatUptime, formatClipText, loadTuiPrefs, saveTuiPrefs, validateGroupName, CONTEXT_BURN_THRESHOLD, buildSnapshotData, formatSnapshotJson, formatSnapshotMarkdown, formatBroadcastSummary, rankSessions, TOP_SORT_MODES, formatIdleSince, CONTEXT_CEILING_THRESHOLD, buildSessionStats, formatSessionStatsLines, formatStatsJson } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
-import { loadTuiHistory } from "./tui-history.js";
+import { loadTuiHistory, searchHistory } from "./tui-history.js";
 import { ConfigWatcher, formatConfigChange } from "./config-watcher.js";
 import { parseActionLogEntries, parseActivityEntries, mergeTimeline, filterByAge, parseDuration, formatTimelineJson, formatTimelineMarkdown } from "./export.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
@@ -757,6 +757,100 @@ async function main() {
             if (!any)
                 tui.log("system", `  threshold: ${CONTEXT_BURN_THRESHOLD.toLocaleString()} tokens/min`);
         });
+        // wire /pin-all-errors
+        input.onPinAllErrors(() => {
+            const count = tui.pinAllErrors();
+            if (count === 0) {
+                tui.log("system", "pin-all-errors: no error sessions to pin");
+            }
+            else {
+                tui.log("system", `pin-all-errors: pinned ${count} session${count !== 1 ? "s" : ""}`);
+                persistPrefs();
+            }
+        });
+        // wire /export-stats
+        input.onExportStats(() => {
+            const sessions = tui.getSessions();
+            const now = Date.now();
+            const entries = buildSessionStats(sessions, tui.getSessionErrorCounts(), tui.getAllBurnRates(now), tui.getAllFirstSeen(), tui.getAllLastChangeAt(), tui.getAllHealthScores(now), tui.getAllSessionAliases(), now);
+            const ts = new Date(now).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+            const dir = join(homedir(), ".aoaoe");
+            const path = join(dir, `stats-${ts}.json`);
+            try {
+                mkdirSync(dir, { recursive: true });
+                writeFileSync(path, formatStatsJson(entries, pkg ?? "dev", now), "utf-8");
+                tui.log("system", `stats exported: ~/.aoaoe/stats-${ts}.json (${entries.length} sessions)`);
+            }
+            catch (err) {
+                tui.log("error", `export-stats failed: ${err}`);
+            }
+        });
+        // wire /recall — search persisted history
+        input.onRecall((keyword, maxResults) => {
+            const matches = searchHistory(keyword, maxResults);
+            if (matches.length === 0) {
+                tui.log("system", `recall: no matches for "${keyword}" in history`);
+                return;
+            }
+            tui.log("system", `recall: ${matches.length} match${matches.length !== 1 ? "es" : ""} for "${keyword}":`);
+            for (const e of matches) {
+                tui.log("system", `  ${e.time}  ${e.tag}  ${e.text}`);
+            }
+        });
+        // wire /stats per-session summary
+        input.onStats(() => {
+            const sessions = tui.getSessions();
+            if (sessions.length === 0) {
+                tui.log("system", "no sessions — no stats available");
+                return;
+            }
+            const now = Date.now();
+            const entries = buildSessionStats(sessions, tui.getSessionErrorCounts(), tui.getAllBurnRates(now), tui.getAllFirstSeen(), tui.getAllLastChangeAt(), tui.getAllHealthScores(now), tui.getAllSessionAliases(), now);
+            tui.log("system", `/stats — ${entries.length} session${entries.length !== 1 ? "s" : ""}:`);
+            for (const line of formatSessionStatsLines(entries)) {
+                tui.log("system", line);
+            }
+        });
+        // wire /copy session pane output to clipboard
+        input.onCopySession((target) => {
+            // resolve target: null = current drill-down session
+            let lines = null;
+            let label = "current session";
+            if (target === null) {
+                const ddId = tui.getDrilldownId();
+                if (!ddId) {
+                    tui.log("system", "no session in view — use /copy N or drill into a session first");
+                    return;
+                }
+                lines = tui.getSessionOutput(ddId);
+                const s = tui.getSessions().find((s) => s.id === ddId);
+                label = s?.title ?? ddId.slice(0, 8);
+            }
+            else {
+                const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;
+                lines = tui.getSessionOutput(num ?? target);
+                label = target;
+            }
+            if (!lines || lines.length === 0) {
+                tui.log("system", `no output stored for ${label} — session may not have been polled yet`);
+                return;
+            }
+            const text = lines.join("\n") + "\n";
+            try {
+                execSync("pbcopy", { input: text, timeout: 5000 });
+                tui.log("system", `copied ${lines.length} lines from ${label} to clipboard`);
+            }
+            catch {
+                try {
+                    const copyPath = join(homedir(), ".aoaoe", "copy.txt");
+                    writeFileSync(copyPath, text, "utf-8");
+                    tui.log("system", `saved ${lines.length} lines from ${label} to ~/.aoaoe/copy.txt`);
+                }
+                catch (writeErr) {
+                    tui.log("error", `copy failed: ${writeErr}`);
+                }
+            }
+        });
         // wire /rename custom display name
         input.onRename((target, displayName) => {
             const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;

package/dist/input.d.ts

@@ -33,6 +33,11 @@ export type WatchdogHandler = (thresholdMinutes: number | null) => void;
 export type TopHandler = (mode: string) => void;
 export type CeilingHandler = () => void;
 export type RenameHandler = (target: string, name: string) => void;
+export type CopySessionHandler = (target: string | null) => void;
+export type StatsHandler = () => void;
+export type RecallHandler = (keyword: string, maxResults: number) => void;
+export type PinAllErrorsHandler = () => void;
+export type ExportStatsHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -88,6 +93,11 @@ export declare class InputReader {
     private topHandler;
     private ceilingHandler;
     private renameHandler;
+    private copySessionHandler;
+    private statsHandler;
+    private recallHandler;
+    private pinAllErrorsHandler;
+    private exportStatsHandler;
     private aliases;
     private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
@@ -126,6 +136,11 @@ export declare class InputReader {
     onTop(handler: TopHandler): void;
     onCeiling(handler: CeilingHandler): void;
     onRename(handler: RenameHandler): void;
+    onCopySession(handler: CopySessionHandler): void;
+    onStats(handler: StatsHandler): void;
+    onRecall(handler: RecallHandler): void;
+    onPinAllErrors(handler: PinAllErrorsHandler): void;
+    onExportStats(handler: ExportStatsHandler): void;
     /** Set aliases from persisted prefs. */
     setAliases(aliases: Record<string, string>): void;
     /** Get current aliases as a plain object. */

package/dist/input.js

@@ -66,6 +66,11 @@ export class InputReader {
     topHandler = null;
     ceilingHandler = null;
     renameHandler = null;
+    copySessionHandler = null;
+    statsHandler = null;
+    recallHandler = null;
+    pinAllErrorsHandler = null;
+    exportStatsHandler = null;
     aliases = new Map(); // /shortcut → /full command
     mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
@@ -212,6 +217,26 @@ export class InputReader {
     onRename(handler) {
         this.renameHandler = handler;
     }
+    // register a callback for /copy [N|name] — copy session pane output
+    onCopySession(handler) {
+        this.copySessionHandler = handler;
+    }
+    // register a callback for /stats — per-session stats summary
+    onStats(handler) {
+        this.statsHandler = handler;
+    }
+    // register a callback for /recall <keyword> [N] — search history
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
+    // register a callback for /pin-all-errors — pin all error sessions
+    onPinAllErrors(handler) {
+        this.pinAllErrorsHandler = handler;
+    }
+    // register a callback for /export-stats — export stats to JSON file
+    onExportStats(handler) {
+        this.exportStatsHandler = handler;
+    }
     /** Set aliases from persisted prefs. */
     setAliases(aliases) {
         this.aliases.clear();
@@ -448,6 +473,11 @@ ${BOLD}navigation:${RESET}
   /top [mode]        rank sessions by errors (default), burn, or idle
   /ceiling           show context token usage vs limit for all sessions
   /rename N|name [display] set custom display name in TUI (no display = clear)
+  /copy [N|name]     copy session's current pane output to clipboard (default: current drill-down)
+  /stats             show per-session health, errors, burn rate, context %, uptime
+  /recall <keyword>  search persisted activity history (last 7 days) for keyword
+  /pin-all-errors    pin every session currently in error status
+  /export-stats      export /stats output as JSON to ~/.aoaoe/stats-<ts>.json
   /clip [N]          copy last N activity entries to clipboard (default 20)
   /diff N            show activity since bookmark N
   /mark              bookmark current activity position
@@ -837,6 +867,57 @@ ${BOLD}other:${RESET}
                 }
                 break;
             }
+            case "/pin-all-errors":
+                if (this.pinAllErrorsHandler) {
+                    this.pinAllErrorsHandler();
+                }
+                else {
+                    console.error(`${DIM}pin-all-errors not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/export-stats":
+                if (this.exportStatsHandler) {
+                    this.exportStatsHandler();
+                }
+                else {
+                    console.error(`${DIM}export-stats not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/recall": {
+                const recallArgs = line.slice("/recall".length).trim().split(/\s+/);
+                const keyword = recallArgs[0] ?? "";
+                if (!keyword) {
+                    console.error(`${DIM}usage: /recall <keyword> [N] — search activity history (default: last 50 matches)${RESET}`);
+                    break;
+                }
+                const maxN = recallArgs[1] ? parseInt(recallArgs[1], 10) : 50;
+                const limit = isNaN(maxN) || maxN < 1 ? 50 : Math.min(maxN, 500);
+                if (this.recallHandler) {
+                    this.recallHandler(keyword, limit);
+                }
+                else {
+                    console.error(`${DIM}recall not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/stats":
+                if (this.statsHandler) {
+                    this.statsHandler();
+                }
+                else {
+                    console.error(`${DIM}stats not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/copy": {
+                const copyArg = line.slice("/copy".length).trim() || null;
+                if (this.copySessionHandler) {
+                    this.copySessionHandler(copyArg);
+                }
+                else {
+                    console.error(`${DIM}copy not available (no TUI)${RESET}`);
+                }
+                break;
+            }
             case "/rename": {
                 const renameArg = line.slice("/rename".length).trim();
                 if (!renameArg) {

package/dist/tui-history.d.ts

@@ -25,4 +25,10 @@ export declare function loadTuiHistory(maxEntries?: number, filePath?: string, m
 export declare function rotateTuiHistory(filePath?: string, maxSize?: number): boolean;
 /** Default history file path (for wiring in index.ts) */
 export declare const TUI_HISTORY_FILE: string;
+/**
+ * Search history entries by keyword (case-insensitive substring match on text and tag).
+ * Returns up to `maxResults` most recent matching entries (newest last).
+ * Searches both the current and .old history file.
+ */
+export declare function searchHistory(keyword: string, maxResults?: number, filePath?: string, maxAgeMs?: number): HistoryEntry[];
 //# sourceMappingURL=tui-history.d.ts.map

package/dist/tui-history.js

@@ -88,4 +88,51 @@ function isValidEntry(val) {
 }
 /** Default history file path (for wiring in index.ts) */
 export const TUI_HISTORY_FILE = HISTORY_FILE;
+/**
+ * Search history entries by keyword (case-insensitive substring match on text and tag).
+ * Returns up to `maxResults` most recent matching entries (newest last).
+ * Searches both the current and .old history file.
+ */
+export function searchHistory(keyword, maxResults = 50, filePath = HISTORY_FILE, maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
+    const lower = keyword.toLowerCase();
+    const results = [];
+    // helper: collect matches from one file
+    const collectFrom = (fp) => {
+        try {
+            if (!existsSync(fp))
+                return;
+            const content = readFileSync(fp, "utf-8");
+            const cutoff = Date.now() - maxAgeMs;
+            for (const line of content.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const e = JSON.parse(line);
+                    if (!isValidEntry(e) || e.ts < cutoff)
+                        continue;
+                    if (e.text.toLowerCase().includes(lower) || e.tag.toLowerCase().includes(lower)) {
+                        results.push(e);
+                    }
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+        catch { /* ignore unreadable file */ }
+    };
+    // search .old first (older), then current (newer)
+    collectFrom(filePath + ".old");
+    collectFrom(filePath);
+    // deduplicate by ts+text, sort newest last, cap to maxResults
+    const seen = new Set();
+    const deduped = [];
+    for (const e of results) {
+        const key = `${e.ts}:${e.text}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(e);
+        }
+    }
+    deduped.sort((a, b) => a.ts - b.ts);
+    return deduped.slice(-maxResults);
+}
 //# sourceMappingURL=tui-history.js.map

package/dist/tui.d.ts

@@ -28,12 +28,32 @@ declare const COMPACT_NAME_LEN = 10;
 declare const PIN_ICON = "\u25B2";
 /**
  * Format sessions as inline compact tokens, wrapped to fit maxWidth.
- * Each token: "{idx}{pin?}{mute?}{dot}{name}" — e.g. "1▲●Alpha" for pinned, "2◌●Bravo" for muted.
+ * Each token: "{idx}{pin?}{mute?}{dot}{name}{health?}" — e.g. "1▲●Alpha" for pinned, "2◌●Bravo" for muted.
  * Returns array of formatted row strings (one per display row).
  */
-declare function formatCompactRows(sessions: DaemonSessionState[], maxWidth: number, pinnedIds?: Set<string>, mutedIds?: Set<string>, noteIds?: Set<string>): string[];
+declare function formatCompactRows(sessions: DaemonSessionState[], maxWidth: number, pinnedIds?: Set<string>, mutedIds?: Set<string>, noteIds?: Set<string>, healthScores?: Map<string, number>, activityRates?: Map<string, number>): string[];
 /** Compute how many display rows compact mode needs (minimum 1). */
 declare function computeCompactRowCount(sessions: DaemonSessionState[], maxWidth: number): number;
+/** Window for computing per-session activity rate (5 minutes). */
+export declare const ACTIVITY_RATE_WINDOW_MS: number;
+/**
+ * Compute messages-per-minute for a session from the activity buffer.
+ * Only counts entries within the last ACTIVITY_RATE_WINDOW_MS.
+ * Returns 0 when no activity in window.
+ */
+export declare function computeSessionActivityRate(buffer: readonly {
+    sessionId?: string;
+}[], timestamps: readonly number[], sessionId: string, now?: number, windowMs?: number): number;
+/**
+ * Format activity rate as a compact badge for compact mode tokens.
+ * Returns empty string when rate is 0 (no clutter for quiet sessions).
+ * Format: "3/m" (rounded to nearest integer messages/min).
+ */
+export declare function formatActivityRateBadge(rate: number): string;
+/** Format watchdog status tag for the header (empty string when disabled). */
+export declare function formatWatchdogTag(thresholdMs: number | null): string;
+/** Format group filter tag for the header (empty string when no filter). */
+export declare function formatGroupFilterTag(groupFilter: string | null): string;
 declare function phaseDisplay(phase: DaemonPhase, paused: boolean, spinnerFrame: number): string;
 export interface ActivityEntry {
     time: string;
@@ -74,6 +94,28 @@ export declare function formatUptime(ms: number): string;
  * Returns empty string if under threshold (< thresholdMs, default 2 min — not worth showing).
  */
 export declare function formatIdleSince(ms: number, thresholdMs?: number): string;
+export interface SessionStatEntry {
+    title: string;
+    displayName?: string;
+    status: string;
+    health: number;
+    errors: number;
+    burnRatePerMin: number | null;
+    contextPct: number | null;
+    uptimeMs: number | null;
+    idleSinceMs: number | null;
+}
+/**
+ * Build stats entries for all sessions — pure, testable, no side effects.
+ */
+export declare function buildSessionStats(sessions: readonly DaemonSessionState[], errorCounts: ReadonlyMap<string, number>, burnRates: ReadonlyMap<string, number | null>, firstSeen: ReadonlyMap<string, number>, lastChangeAt: ReadonlyMap<string, number>, healthScores: ReadonlyMap<string, number>, sessionAliases: ReadonlyMap<string, string>, now?: number): SessionStatEntry[];
+/**
+ * Format session stats entries as a multi-line activity-log-friendly string.
+ * Each line is one session summary.
+ */
+export declare function formatSessionStatsLines(entries: SessionStatEntry[]): string[];
+/** Format session stats entries as a JSON object for export. */
+export declare function formatStatsJson(entries: SessionStatEntry[], version: string, now?: number): string;
 /** Max visible length for a custom session display name. */
 export declare const MAX_RENAME_LEN = 32;
 /** Truncate a custom display name to the max length. */
@@ -251,6 +293,11 @@ export declare class TUI {
      * Pinned sessions always sort to the top. Returns true if session found.
      */
     togglePin(sessionIdOrIndex: string | number): boolean;
+    /**
+     * Pin all sessions currently in "error" status (or with any cumulative errors).
+     * Returns the count of newly pinned sessions.
+     */
+    pinAllErrors(): number;
     /** Check if a session ID is pinned. */
     isPinned(id: string): boolean;
     /** Return count of pinned sessions. */
@@ -304,6 +351,15 @@ export declare class TUI {
     getAllFirstSeen(): ReadonlyMap<string, number>;
     /** Return the activity buffer (for /clip export). */
     getActivityBuffer(): readonly ActivityEntry[];
+    /** Return the activity timestamps (epoch ms per entry, parallel to activityBuffer). */
+    getActivityTimestamps(): readonly number[];
+    /**
+     * Return the stored pane output lines for a session (by 1-indexed number, ID, prefix, or title).
+     * Returns null if session not found or no output stored.
+     */
+    getSessionOutput(sessionIdOrIndex: string | number): string[] | null;
+    /** Return the current drill-down session ID (for /copy default target). */
+    getDrilldownId(): string | null;
     /** Return per-session error counts (for /who). */
     getSessionErrorCounts(): ReadonlyMap<string, number>;
     /** Return recent error timestamps for a session (for sparkline rendering). */
@@ -315,6 +371,8 @@ export declare class TUI {
         current: number;
         max: number;
     } | null>;
+    /** Compute health scores for all sessions and return as a map (id → score). */
+    getAllHealthScores(now?: number): Map<string, number>;
     /** Return all sessions with their current burn rates (tokens/min, null if insufficient data). */
     getAllBurnRates(now?: number): Map<string, number | null>;
     /**

package/dist/tui.js

@@ -100,10 +100,10 @@ const COMPACT_NAME_LEN = 10;
 const PIN_ICON = "▲";
 /**
  * Format sessions as inline compact tokens, wrapped to fit maxWidth.
- * Each token: "{idx}{pin?}{mute?}{dot}{name}" — e.g. "1▲●Alpha" for pinned, "2◌●Bravo" for muted.
+ * Each token: "{idx}{pin?}{mute?}{dot}{name}{health?}" — e.g. "1▲●Alpha" for pinned, "2◌●Bravo" for muted.
  * Returns array of formatted row strings (one per display row).
  */
-function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds) {
+function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds, healthScores, activityRates) {
     if (sessions.length === 0)
         return [`${DIM}no agents connected${RESET}`];
     const tokens = [];
@@ -119,8 +119,17 @@ function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds) {
         const muteIcon = muted ? `${DIM}${MUTE_ICON}${RESET}` : "";
         const noteIcon = noted ? `${TEAL}${NOTE_ICON}${RESET}` : "";
         const name = truncatePlain(s.title, COMPACT_NAME_LEN);
-        tokens.push(`${SLATE}${idx}${RESET}${pin}${muteIcon}${noteIcon}${dot}${BOLD}${name}${RESET}`);
-        widths.push(idx.length + (pinned ? 1 : 0) + (muted ? 1 : 0) + (noted ? 1 : 0) + 1 + name.length);
+        // health indicator: single ⬡ glyph when score < HEALTH_GOOD, colored by severity
+        const score = healthScores?.get(s.id);
+        const healthGlyph = (score !== undefined && score < HEALTH_GOOD)
+            ? `${score < HEALTH_WARN ? ROSE : AMBER}${HEALTH_ICON}${RESET}` : "";
+        const healthWidth = (score !== undefined && score < HEALTH_GOOD) ? 1 : 0;
+        // activity rate badge: "3/m" when rate > 0
+        const rate = activityRates?.get(s.id) ?? 0;
+        const rateBadge = formatActivityRateBadge(rate);
+        const rateVisible = rateBadge ? stripAnsiForLen(rateBadge) : 0;
+        tokens.push(`${SLATE}${idx}${RESET}${pin}${muteIcon}${noteIcon}${dot}${BOLD}${name}${RESET}${healthGlyph}${rateBadge}`);
+        widths.push(idx.length + (pinned ? 1 : 0) + (muted ? 1 : 0) + (noted ? 1 : 0) + 1 + name.length + healthWidth + rateVisible);
     }
     const rows = [];
     let currentRow = "";
@@ -145,6 +154,49 @@ function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds) {
 function computeCompactRowCount(sessions, maxWidth) {
     return Math.max(1, formatCompactRows(sessions, maxWidth).length);
 }
+// ── Activity rate helpers (pure, exported for testing) ───────────────────────
+/** Window for computing per-session activity rate (5 minutes). */
+export const ACTIVITY_RATE_WINDOW_MS = 5 * 60_000;
+/**
+ * Compute messages-per-minute for a session from the activity buffer.
+ * Only counts entries within the last ACTIVITY_RATE_WINDOW_MS.
+ * Returns 0 when no activity in window.
+ */
+export function computeSessionActivityRate(buffer, timestamps, sessionId, now, windowMs = ACTIVITY_RATE_WINDOW_MS) {
+    const nowMs = now ?? Date.now();
+    const cutoff = nowMs - windowMs;
+    let count = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i].sessionId === sessionId && (timestamps[i] ?? 0) >= cutoff)
+            count++;
+    }
+    return count === 0 ? 0 : (count / windowMs) * 60_000;
+}
+/**
+ * Format activity rate as a compact badge for compact mode tokens.
+ * Returns empty string when rate is 0 (no clutter for quiet sessions).
+ * Format: "3/m" (rounded to nearest integer messages/min).
+ */
+export function formatActivityRateBadge(rate) {
+    if (rate <= 0)
+        return "";
+    const rounded = Math.max(1, Math.round(rate));
+    return `${DIM}${rounded}/m${RESET}`;
+}
+// ── Header status tag helpers (pure, exported for testing) ──────────────────
+/** Format watchdog status tag for the header (empty string when disabled). */
+export function formatWatchdogTag(thresholdMs) {
+    if (thresholdMs === null)
+        return "";
+    const mins = Math.round(thresholdMs / 60_000);
+    return `⊛${mins}m`;
+}
+/** Format group filter tag for the header (empty string when no filter). */
+export function formatGroupFilterTag(groupFilter) {
+    if (!groupFilter)
+        return "";
+    return `${GROUP_ICON}${groupFilter}`;
+}
 // ── Status rendering ────────────────────────────────────────────────────────
 const STATUS_DOT = {
     working: `${LIME}${DOT.filled}${RESET}`,
@@ -259,6 +311,56 @@ export function formatIdleSince(ms, thresholdMs = 2 * 60_000) {
         return "";
     return `idle ${formatUptime(ms)}`;
 }
+/**
+ * Build stats entries for all sessions — pure, testable, no side effects.
+ */
+export function buildSessionStats(sessions, errorCounts, burnRates, firstSeen, lastChangeAt, healthScores, sessionAliases, now) {
+    const nowMs = now ?? Date.now();
+    return sessions.map((s) => {
+        const ceiling = parseContextCeiling(s.contextTokens);
+        const ctxPct = ceiling ? Math.round((ceiling.current / ceiling.max) * 100) : null;
+        const fs = firstSeen.get(s.id);
+        const lc = lastChangeAt.get(s.id);
+        return {
+            title: s.title,
+            displayName: sessionAliases.get(s.id),
+            status: s.status,
+            health: healthScores.get(s.id) ?? 100,
+            errors: errorCounts.get(s.id) ?? 0,
+            burnRatePerMin: burnRates.get(s.id) ?? null,
+            contextPct: ctxPct,
+            uptimeMs: fs !== undefined ? nowMs - fs : null,
+            idleSinceMs: lc !== undefined ? nowMs - lc : null,
+        };
+    });
+}
+/**
+ * Format session stats entries as a multi-line activity-log-friendly string.
+ * Each line is one session summary.
+ */
+export function formatSessionStatsLines(entries) {
+    if (entries.length === 0)
+        return ["  no sessions"];
+    return entries.map((e) => {
+        const label = e.displayName ? `${e.displayName} (${e.title})` : e.title;
+        const healthStr = `⬡${e.health}`;
+        const errStr = e.errors > 0 ? ` ${e.errors}err` : "";
+        const burnStr = e.burnRatePerMin !== null && e.burnRatePerMin > 0
+            ? ` ${Math.round(e.burnRatePerMin / 100) * 100}tok/min` : "";
+        const ctxStr = e.contextPct !== null ? ` ctx:${e.contextPct}%` : "";
+        const upStr = e.uptimeMs !== null ? ` up:${formatUptime(e.uptimeMs)}` : "";
+        const idleStr = e.idleSinceMs !== null ? ` ${formatIdleSince(e.idleSinceMs)}` : "";
+        return `  ${label} [${e.status}] ${healthStr}${errStr}${burnStr}${ctxStr}${upStr}${idleStr}`;
+    });
+}
+/** Format session stats entries as a JSON object for export. */
+export function formatStatsJson(entries, version, now) {
+    return JSON.stringify({
+        version,
+        exportedAt: new Date(now ?? Date.now()).toISOString(),
+        sessions: entries,
+    }, null, 2) + "\n";
+}
 // ── Session rename ────────────────────────────────────────────────────────────
 /** Max visible length for a custom session display name. */
 export const MAX_RENAME_LEN = 32;
@@ -281,7 +383,7 @@ export const BUILTIN_COMMANDS = new Set([
     "/pin", "/bell", "/focus", "/mute", "/unmute-all", "/filter", "/who",
     "/uptime", "/auto-pin", "/note", "/notes", "/clip", "/diff", "/mark",
     "/jump", "/marks", "/search", "/alias", "/insist", "/task", "/tasks",
-    "/group", "/groups", "/group-filter", "/burn-rate", "/snapshot", "/broadcast", "/watchdog", "/top", "/ceiling", "/rename",
+    "/group", "/groups", "/group-filter", "/burn-rate", "/snapshot", "/broadcast", "/watchdog", "/top", "/ceiling", "/rename", "/copy", "/stats", "/recall", "/pin-all-errors", "/export-stats",
 ]);
 /** Resolve a slash command through the alias map. Returns the expanded command or the original. */
 export function resolveAlias(line, aliases) {
@@ -660,6 +762,25 @@ export class TUI {
         }
         return true;
     }
+    /**
+     * Pin all sessions currently in "error" status (or with any cumulative errors).
+     * Returns the count of newly pinned sessions.
+     */
+    pinAllErrors() {
+        let pinned = 0;
+        for (const s of this.sessions) {
+            if ((s.status === "error" || (this.sessionErrorCounts.get(s.id) ?? 0) > 0) && !this.pinnedIds.has(s.id)) {
+                this.pinnedIds.add(s.id);
+                pinned++;
+            }
+        }
+        if (pinned > 0) {
+            this.sessions = sortSessions(this.sessions, this.sortMode, this.lastChangeAt, this.pinnedIds);
+            if (this.active)
+                this.paintSessions();
+        }
+        return pinned;
+    }
     /** Check if a session ID is pinned. */
     isPinned(id) {
         return this.pinnedIds.has(id);
@@ -829,6 +950,32 @@ export class TUI {
     getActivityBuffer() {
         return this.activityBuffer;
     }
+    /** Return the activity timestamps (epoch ms per entry, parallel to activityBuffer). */
+    getActivityTimestamps() {
+        return this.activityTimestamps;
+    }
+    /**
+     * Return the stored pane output lines for a session (by 1-indexed number, ID, prefix, or title).
+     * Returns null if session not found or no output stored.
+     */
+    getSessionOutput(sessionIdOrIndex) {
+        let sessionId;
+        if (typeof sessionIdOrIndex === "number") {
+            sessionId = this.sessions[sessionIdOrIndex - 1]?.id;
+        }
+        else {
+            const needle = sessionIdOrIndex.toLowerCase();
+            const match = this.sessions.find((s) => s.id === sessionIdOrIndex || s.id.startsWith(needle) || s.title.toLowerCase() === needle);
+            sessionId = match?.id;
+        }
+        if (!sessionId)
+            return null;
+        return this.sessionOutputs.get(sessionId) ?? null;
+    }
+    /** Return the current drill-down session ID (for /copy default target). */
+    getDrilldownId() {
+        return this.drilldownSessionId;
+    }
     /** Return per-session error counts (for /who). */
     getSessionErrorCounts() {
         return this.sessionErrorCounts;
@@ -849,6 +996,27 @@ export class TUI {
         }
         return result;
     }
+    /** Compute health scores for all sessions and return as a map (id → score). */
+    getAllHealthScores(now) {
+        const nowMs = now ?? Date.now();
+        const result = new Map();
+        for (const s of this.sessions) {
+            const ceiling = parseContextCeiling(s.contextTokens);
+            const cf = ceiling ? ceiling.current / ceiling.max : null;
+            const bh = this.sessionContextHistory.get(s.id);
+            const br = bh ? computeContextBurnRate(bh, nowMs) : null;
+            const lc = this.lastChangeAt.get(s.id);
+            const idle = lc !== undefined ? nowMs - lc : null;
+            result.set(s.id, computeHealthScore({
+                errorCount: this.sessionErrorCounts.get(s.id) ?? 0,
+                burnRatePerMin: br,
+                contextFraction: cf,
+                idleMs: idle,
+                watchdogThresholdMs: this.watchdogThresholdMs,
+            }));
+        }
+        return result;
+    }
     /** Return all sessions with their current burn rates (tokens/min, null if insufficient data). */
     getAllBurnRates(now) {
         const result = new Map();
@@ -1483,7 +1651,12 @@ export class TUI {
             }
             // reasoner badge
             const reasonerTag = this.reasonerName ? `  ${SLATE}│${RESET}  ${TEAL}${this.reasonerName}${RESET}` : "";
-            line = ` ${INDIGO}${BOLD}aoaoe${RESET} ${SLATE}${this.version}${RESET}  ${SLATE}│${RESET}  #${this.pollCount}  ${SLATE}│${RESET}  ${sessCount}  ${SLATE}│${RESET}  ${phaseText}${activeTag}${countdownTag}${reasonerTag}`;
+            // watchdog indicator — show threshold when active
+            const wdMin = this.watchdogThresholdMs !== null ? Math.round(this.watchdogThresholdMs / 60_000) : null;
+            const watchdogTag = wdMin !== null ? `  ${SLATE}│${RESET}  ${AMBER}⊛${wdMin}m${RESET}` : "";
+            // group filter indicator
+            const groupFilterTag = this.groupFilter ? `  ${SLATE}│${RESET}  ${TEAL}${GROUP_ICON}${this.groupFilter}${RESET}` : "";
+            line = ` ${INDIGO}${BOLD}aoaoe${RESET} ${SLATE}${this.version}${RESET}  ${SLATE}│${RESET}  #${this.pollCount}  ${SLATE}│${RESET}  ${sessCount}  ${SLATE}│${RESET}  ${phaseText}${activeTag}${countdownTag}${watchdogTag}${groupFilterTag}${reasonerTag}`;
         }
         process.stderr.write(SAVE_CURSOR +
             moveTo(1, 1) + CLEAR_LINE + BG_DARK + WHITE + truncateAnsi(line, this.cols) + padToWidth(line, this.cols) + RESET +
@@ -1521,9 +1694,30 @@ export class TUI {
             process.stderr.write(moveTo(startRow + 1, 1) + CLEAR_LINE + padded);
         }
         else if (this.compactMode) {
-            // compact: inline tokens, multiple per row (with pin indicators)
+            // compact: inline tokens, multiple per row (with pin indicators + health glyphs)
+            const nowMsCompact = Date.now();
             const noteIdSet = new Set(this.sessionNotes.keys());
-            const compactRows = formatCompactRows(visibleSessions, innerWidth - 1, this.pinnedIds, this.mutedIds, noteIdSet);
+            const compactHealthScores = new Map();
+            for (const s of visibleSessions) {
+                const ceilingC = parseContextCeiling(s.contextTokens);
+                const cfC = ceilingC ? ceilingC.current / ceilingC.max : null;
+                const bhC = this.sessionContextHistory.get(s.id);
+                const brC = bhC ? computeContextBurnRate(bhC, nowMsCompact) : null;
+                const lcC = this.lastChangeAt.get(s.id);
+                const idleC = lcC !== undefined ? nowMsCompact - lcC : null;
+                compactHealthScores.set(s.id, computeHealthScore({
+                    errorCount: this.sessionErrorCounts.get(s.id) ?? 0,
+                    burnRatePerMin: brC,
+                    contextFraction: cfC,
+                    idleMs: idleC,
+                    watchdogThresholdMs: this.watchdogThresholdMs,
+                }));
+            }
+            const compactActivityRates = new Map();
+            for (const s of visibleSessions) {
+                compactActivityRates.set(s.id, computeSessionActivityRate(this.activityBuffer, this.activityTimestamps, s.id, nowMsCompact));
+            }
+            const compactRows = formatCompactRows(visibleSessions, innerWidth - 1, this.pinnedIds, this.mutedIds, noteIdSet, compactHealthScores, compactActivityRates);
             for (let r = 0; r < compactRows.length; r++) {
                 const line = `${SLATE}${BOX.v}${RESET} ${compactRows[r]}`;
                 const padded = padBoxLine(line, this.cols);

package/package.json

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