aoaoe 0.116.0 → 0.126.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, validateSessionTag } 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";
@@ -190,17 +190,22 @@ async function main() {
             tui.restoreGroups(prefs.sessionGroups);
         if (prefs.sessionAliases)
             tui.restoreSessionAliases(prefs.sessionAliases);
+        if (prefs.sessionTags)
+            tui.restoreSessionTags(prefs.sessionTags);
     }
     const persistPrefs = () => {
         if (!tui)
             return;
-        // persist session groups (ID → group tag) and session aliases (ID → display name)
+        // persist session groups, aliases, and multi-tags
         const groupsObj = {};
         for (const [id, g] of tui.getAllGroups())
             groupsObj[id] = g;
         const aliasesObj = {};
         for (const [id, name] of tui.getAllSessionAliases())
             aliasesObj[id] = name;
+        const sTagsObj = {};
+        for (const [id, tset] of tui.getAllSessionTags())
+            sTagsObj[id] = [...tset];
         saveTuiPrefs({
             sortMode: tui.getSortMode(),
             compact: tui.isCompact(),
@@ -211,6 +216,7 @@ async function main() {
             aliases: input.getAliases(),
             sessionGroups: groupsObj,
             sessionAliases: aliasesObj,
+            sessionTags: sTagsObj,
         });
     };
     if (!useTui) {
@@ -757,6 +763,123 @@ async function main() {
             if (!any)
                 tui.log("system", `  threshold: ${CONTEXT_BURN_THRESHOLD.toLocaleString()} tokens/min`);
         });
+        // wire /mute-errors toggle
+        input.onMuteErrors(() => {
+            const muted = tui.toggleMuteErrors();
+            tui.log("system", `mute-errors: ${muted ? "on — error entries hidden from activity log" : "off — all entries visible"}`);
+        });
+        // wire /prev-goal
+        input.onPrevGoal((target, nBack) => {
+            const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;
+            const sessions = tui.getSessions();
+            const session = num !== undefined
+                ? sessions[num - 1]
+                : sessions.find((s) => s.title.toLowerCase() === target.toLowerCase() || s.id.startsWith(target));
+            if (!session) {
+                tui.log("system", `session not found: ${target}`);
+                return;
+            }
+            const goal = tui.getPreviousGoal(session.id, nBack);
+            if (!goal) {
+                tui.log("system", `no goal history for ${session.title} (${nBack} back)`);
+                return;
+            }
+            // queue as a task update for that session
+            input.inject(`__CMD_QUICKTASK__${goal}`);
+            tui.log("system", `prev-goal restored for ${session.title}: "${goal}"`);
+        });
+        // wire /tag set session tags
+        input.onTag((target, tags) => {
+            for (const t of tags) {
+                const err = validateSessionTag(t);
+                if (err) {
+                    tui.log("system", `invalid tag "${t}": ${err}`);
+                    return;
+                }
+            }
+            const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;
+            const ok = tui.setSessionTags(num ?? target, tags);
+            if (ok) {
+                if (tags.length > 0) {
+                    tui.log("system", `tags set for ${target}: ${tags.join(", ")}`);
+                }
+                else {
+                    tui.log("system", `tags cleared for ${target}`);
+                }
+                persistPrefs();
+            }
+            else {
+                tui.log("system", `session not found: ${target}`);
+            }
+        });
+        // wire /tags list
+        input.onTagsList(() => {
+            const allTags = tui.getAllSessionTags();
+            if (allTags.size === 0) {
+                tui.log("system", "no tags — use /tag <N|name> <tag1,tag2> to assign");
+                return;
+            }
+            const sessions = tui.getSessions();
+            for (const [id, tset] of allTags) {
+                const s = sessions.find((s) => s.id === id);
+                const label = s?.title ?? id.slice(0, 8);
+                tui.log("system", `  ${label}: ${[...tset].sort().join(", ")}`);
+            }
+        });
+        // 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

package/dist/input.d.ts

@@ -34,6 +34,14 @@ 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 type MuteErrorsHandler = () => void;
+export type PrevGoalHandler = (target: string, nBack: number) => void;
+export type TagHandler = (target: string, tags: string[]) => void;
+export type TagsListHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -90,6 +98,14 @@ export declare class InputReader {
     private ceilingHandler;
     private renameHandler;
     private copySessionHandler;
+    private statsHandler;
+    private recallHandler;
+    private pinAllErrorsHandler;
+    private exportStatsHandler;
+    private muteErrorsHandler;
+    private prevGoalHandler;
+    private tagHandler;
+    private tagsListHandler;
     private aliases;
     private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
@@ -129,6 +145,14 @@ export declare class InputReader {
     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;
+    onMuteErrors(handler: MuteErrorsHandler): void;
+    onPrevGoal(handler: PrevGoalHandler): void;
+    onTag(handler: TagHandler): void;
+    onTagsList(handler: TagsListHandler): void;
     /** Set aliases from persisted prefs. */
     setAliases(aliases: Record<string, string>): void;
     /** Get current aliases as a plain object. */

package/dist/input.js

@@ -67,6 +67,14 @@ export class InputReader {
     ceilingHandler = null;
     renameHandler = null;
     copySessionHandler = null;
+    statsHandler = null;
+    recallHandler = null;
+    pinAllErrorsHandler = null;
+    exportStatsHandler = null;
+    muteErrorsHandler = null;
+    prevGoalHandler = null;
+    tagHandler = null;
+    tagsListHandler = null;
     aliases = new Map(); // /shortcut → /full command
     mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
@@ -217,6 +225,38 @@ export class InputReader {
     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;
+    }
+    // register a callback for /mute-errors — toggle error-tag suppression
+    onMuteErrors(handler) {
+        this.muteErrorsHandler = handler;
+    }
+    // register a callback for /prev-goal <N|name> [nBack] — restore previous goal
+    onPrevGoal(handler) {
+        this.prevGoalHandler = handler;
+    }
+    // register a callback for /tag <N|name> [tag1,tag2] — set session tags
+    onTag(handler) {
+        this.tagHandler = handler;
+    }
+    // register a callback for /tags — list all session tags
+    onTagsList(handler) {
+        this.tagsListHandler = handler;
+    }
     /** Set aliases from persisted prefs. */
     setAliases(aliases) {
         this.aliases.clear();
@@ -363,7 +403,13 @@ export class InputReader {
             this.rl?.prompt();
             return;
         }
-        // quick-switch: bare digit 1-9 jumps to that session
+        // quick-switch: bare digit 1-9, or g+N for sessions 1-99
+        const gSwitch = line.match(/^g([1-9]\d?)$/);
+        if (gSwitch && this.quickSwitchHandler) {
+            this.quickSwitchHandler(parseInt(gSwitch[1], 10));
+            this.rl?.prompt();
+            return;
+        }
         if (/^[1-9]$/.test(line) && this.quickSwitchHandler) {
             this.quickSwitchHandler(parseInt(line, 10));
             this.rl?.prompt();
@@ -428,6 +474,7 @@ ${BOLD}controls:${RESET}
 
 ${BOLD}navigation:${RESET}
   1-9                quick-switch: jump to session N (type digit + Enter)
+  g1-g99             quick-switch for sessions 10+ (e.g. g12 jumps to session 12)
   /view [N|name]     drill into a session's live output (default: 1)
   /back              return to overview from drill-down
   /sort [mode]       sort sessions: status, name, activity, default (or cycle)
@@ -454,6 +501,14 @@ ${BOLD}navigation:${RESET}
   /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
+  /mute-errors       toggle suppression of error/! action entries in activity log
+  /prev-goal N [n]   restore Nth session's goal from history (n=1 most recent)
+  /tag N tag1,tag2   set freeform tags on a session (no tags = clear)
+  /tags              list all session tags
   /clip [N]          copy last N activity entries to clipboard (default 20)
   /diff N            show activity since bookmark N
   /mark              bookmark current activity position
@@ -843,6 +898,103 @@ ${BOLD}other:${RESET}
                 }
                 break;
             }
+            case "/mute-errors":
+                if (this.muteErrorsHandler) {
+                    this.muteErrorsHandler();
+                }
+                else {
+                    console.error(`${DIM}mute-errors not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/prev-goal": {
+                const pgArgs = line.slice("/prev-goal".length).trim().split(/\s+/);
+                const pgTarget = pgArgs[0] ?? "";
+                const pgN = pgArgs[1] ? parseInt(pgArgs[1], 10) : 1;
+                if (!pgTarget) {
+                    console.error(`${DIM}usage: /prev-goal <N|name> [n] — restore nth most-recent goal (default 1)${RESET}`);
+                    break;
+                }
+                if (this.prevGoalHandler) {
+                    this.prevGoalHandler(pgTarget, isNaN(pgN) || pgN < 1 ? 1 : pgN);
+                }
+                else {
+                    console.error(`${DIM}prev-goal not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/tag": {
+                const tagArgs = line.slice("/tag".length).trim();
+                if (!tagArgs) {
+                    console.error(`${DIM}usage: /tag <N|name> [tag1,tag2,...] — set tags (no tags = clear)${RESET}`);
+                    break;
+                }
+                if (this.tagHandler) {
+                    const spaceIdx = tagArgs.indexOf(" ");
+                    if (spaceIdx > 0) {
+                        const target = tagArgs.slice(0, spaceIdx);
+                        const rawTags = tagArgs.slice(spaceIdx + 1).trim();
+                        const tags = rawTags ? rawTags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+                        this.tagHandler(target, tags);
+                    }
+                    else {
+                        // target only — clear tags
+                        this.tagHandler(tagArgs, []);
+                    }
+                }
+                else {
+                    console.error(`${DIM}tag not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/tags":
+                if (this.tagsListHandler) {
+                    this.tagsListHandler();
+                }
+                else {
+                    console.error(`${DIM}tags not available (no TUI)${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) {

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

@@ -31,9 +31,29 @@ declare const PIN_ICON = "\u25B2";
  * 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>, healthScores?: Map<string, number>): 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,45 @@ 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;
+/**
+ * Check if an activity entry's tag matches any tag in the suppressed set.
+ * Handles pipe-separated patterns (same logic as matchesTagFilter).
+ */
+export declare function isSuppressedEntry(entry: ActivityEntry, suppressedTags: ReadonlySet<string>): boolean;
+/** Default error-suppression pattern matching "! action" and "error" tags. */
+export declare const MUTE_ERRORS_PATTERN = "error|! action";
+/** Max previous goals stored per session. */
+export declare const MAX_GOAL_HISTORY = 5;
+/** Max tags per session. */
+export declare const MAX_SESSION_TAGS = 10;
+/** Max length of a single session tag. */
+export declare const MAX_SESSION_TAG_LEN = 20;
+/** Validate a session tag name. Returns null if valid, error string if not. */
+export declare function validateSessionTag(tag: string): string | null;
+/** Format a session tags badge for display in cards. Returns empty string if no tags. */
+export declare function formatSessionTagsBadge(tags: ReadonlySet<string>): 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. */
@@ -171,6 +230,7 @@ export interface TuiPrefs {
     aliases?: Record<string, string>;
     sessionGroups?: Record<string, string>;
     sessionAliases?: Record<string, string>;
+    sessionTags?: Record<string, string[]>;
 }
 /** Load persisted TUI preferences. Returns empty object on any error. */
 export declare function loadTuiPrefs(): TuiPrefs;
@@ -221,6 +281,9 @@ export declare class TUI {
     private sessionAliases;
     private watchdogThresholdMs;
     private watchdogAlerted;
+    private suppressedTags;
+    private sessionGoalHistory;
+    private sessionTags;
     private viewMode;
     private drilldownSessionId;
     private sessionOutputs;
@@ -251,6 +314,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 +372,33 @@ export declare class TUI {
     getAllFirstSeen(): ReadonlyMap<string, number>;
     /** Return the activity buffer (for /clip export). */
     getActivityBuffer(): readonly ActivityEntry[];
+    /** Toggle suppression of error-tagged entries ("! action" and "error"). */
+    toggleMuteErrors(): boolean;
+    /** Return whether error tags are currently suppressed. */
+    isErrorsMuted(): boolean;
+    /** Return the full suppressed-tags set (readonly). */
+    getSuppressedTags(): ReadonlySet<string>;
+    /** Record a goal for a session (push to front of history, cap at MAX_GOAL_HISTORY). */
+    pushGoalHistory(sessionId: string, goal: string): void;
+    /** Get goal history for a session (oldest first, most recent last). */
+    getGoalHistory(sessionId: string): readonly string[];
+    /** Restore a previous goal (1 = most recent, 2 = two back, etc.). Returns the goal string or null. */
+    getPreviousGoal(sessionId: string, nBack?: number): string | null;
+    /**
+     * Set tags for a session (replaces existing). Pass empty array to clear.
+     * Returns true if session found.
+     */
+    setSessionTags(sessionIdOrIndex: string | number, tags: string[]): boolean;
+    /** Get tags for a session ID (empty set if none). */
+    getSessionTags(id: string): ReadonlySet<string>;
+    /** Return all session tags (id → tag set). */
+    getAllSessionTags(): ReadonlyMap<string, ReadonlySet<string>>;
+    /** Return sessions that have a given tag. */
+    getSessionsWithTag(tag: string): DaemonSessionState[];
+    /** Restore session tags from persisted prefs. */
+    restoreSessionTags(tags: Record<string, string[]>): void;
+    /** 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.
@@ -322,6 +417,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>;
     /**
@@ -385,6 +482,8 @@ export declare class TUI {
     }): void;
     log(tag: string, text: string, sessionId?: string): void;
     replayHistory(entries: HistoryEntry[]): void;
+    /** Apply all active display filters to an entry array: mute, suppress, tag, search. */
+    private applyDisplayFilters;
     scrollUp(lines?: number): void;
     scrollDown(lines?: number): void;
     scrollToTop(): void;

package/dist/tui.js

@@ -103,7 +103,7 @@ const PIN_ICON = "▲";
  * 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, healthScores) {
+function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds, healthScores, activityRates) {
     if (sessions.length === 0)
         return [`${DIM}no agents connected${RESET}`];
     const tokens = [];
@@ -124,8 +124,12 @@ function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds, hea
         const healthGlyph = (score !== undefined && score < HEALTH_GOOD)
             ? `${score < HEALTH_WARN ? ROSE : AMBER}${HEALTH_ICON}${RESET}` : "";
         const healthWidth = (score !== undefined && score < HEALTH_GOOD) ? 1 : 0;
-        tokens.push(`${SLATE}${idx}${RESET}${pin}${muteIcon}${noteIcon}${dot}${BOLD}${name}${RESET}${healthGlyph}`);
-        widths.push(idx.length + (pinned ? 1 : 0) + (muted ? 1 : 0) + (noted ? 1 : 0) + 1 + name.length + healthWidth);
+        // 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 = "";
@@ -150,6 +154,49 @@ function formatCompactRows(sessions, maxWidth, pinnedIds, mutedIds, noteIds, hea
 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}`,
@@ -264,6 +311,97 @@ export function formatIdleSince(ms, thresholdMs = 2 * 60_000) {
         return "";
     return `idle ${formatUptime(ms)}`;
 }
+// ── Suppressed tags (mute-errors style) ──────────────────────────────────────
+/**
+ * Check if an activity entry's tag matches any tag in the suppressed set.
+ * Handles pipe-separated patterns (same logic as matchesTagFilter).
+ */
+export function isSuppressedEntry(entry, suppressedTags) {
+    if (suppressedTags.size === 0)
+        return false;
+    for (const pattern of suppressedTags) {
+        if (matchesTagFilter(entry, pattern))
+            return true;
+    }
+    return false;
+}
+/** Default error-suppression pattern matching "! action" and "error" tags. */
+export const MUTE_ERRORS_PATTERN = "error|! action";
+// ── Per-session goal history ──────────────────────────────────────────────────
+/** Max previous goals stored per session. */
+export const MAX_GOAL_HISTORY = 5;
+// ── Session multi-tags ────────────────────────────────────────────────────────
+/** Max tags per session. */
+export const MAX_SESSION_TAGS = 10;
+/** Max length of a single session tag. */
+export const MAX_SESSION_TAG_LEN = 20;
+/** Validate a session tag name. Returns null if valid, error string if not. */
+export function validateSessionTag(tag) {
+    if (!tag || tag.trim().length === 0)
+        return "tag cannot be empty";
+    const t = tag.trim();
+    if (t.length > MAX_SESSION_TAG_LEN)
+        return `tag too long (max ${MAX_SESSION_TAG_LEN})`;
+    if (!/^[a-z0-9_-]+$/i.test(t))
+        return "tag must be alphanumeric (a-z, 0-9, - _)";
+    return null;
+}
+/** Format a session tags badge for display in cards. Returns empty string if no tags. */
+export function formatSessionTagsBadge(tags) {
+    if (tags.size === 0)
+        return "";
+    return `${DIM}[${[...tags].sort().join(",")}]${RESET}`;
+}
+/**
+ * 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;
@@ -286,7 +424,8 @@ 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", "/copy",
+    "/group", "/groups", "/group-filter", "/burn-rate", "/snapshot", "/broadcast", "/watchdog", "/top", "/ceiling", "/rename", "/copy", "/stats", "/recall", "/pin-all-errors", "/export-stats",
+    "/mute-errors", "/prev-goal", "/tag", "/tags",
 ]);
 /** Resolve a slash command through the alias map. Returns the expanded command or the original. */
 export function resolveAlias(line, aliases) {
@@ -551,6 +690,9 @@ export class TUI {
     sessionAliases = new Map(); // session ID → custom display name
     watchdogThresholdMs = null; // null = disabled; ms of inactivity before alert
     watchdogAlerted = new Map(); // session ID → epoch ms of last watchdog alert
+    suppressedTags = new Set(); // activity tags excluded from display (/mute-errors)
+    sessionGoalHistory = new Map(); // session ID → last N goals (newest last)
+    sessionTags = new Map(); // session ID → freeform tag set
     // drill-down mode: show a single session's full output
     viewMode = "overview";
     drilldownSessionId = null;
@@ -665,6 +807,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);
@@ -834,6 +995,105 @@ export class TUI {
     getActivityBuffer() {
         return this.activityBuffer;
     }
+    // ── Suppressed tags ─────────────────────────────────────────────────────
+    /** Toggle suppression of error-tagged entries ("! action" and "error"). */
+    toggleMuteErrors() {
+        if (this.suppressedTags.has(MUTE_ERRORS_PATTERN)) {
+            this.suppressedTags.delete(MUTE_ERRORS_PATTERN);
+            if (this.active)
+                this.repaintActivityRegion();
+            return false; // now unmuted
+        }
+        this.suppressedTags.add(MUTE_ERRORS_PATTERN);
+        if (this.active)
+            this.repaintActivityRegion();
+        return true; // now muted
+    }
+    /** Return whether error tags are currently suppressed. */
+    isErrorsMuted() {
+        return this.suppressedTags.has(MUTE_ERRORS_PATTERN);
+    }
+    /** Return the full suppressed-tags set (readonly). */
+    getSuppressedTags() {
+        return this.suppressedTags;
+    }
+    // ── Per-session goal history ─────────────────────────────────────────────
+    /** Record a goal for a session (push to front of history, cap at MAX_GOAL_HISTORY). */
+    pushGoalHistory(sessionId, goal) {
+        if (!goal || !goal.trim())
+            return;
+        const hist = this.sessionGoalHistory.get(sessionId) ?? [];
+        // avoid duplicating the same consecutive goal
+        if (hist.length > 0 && hist[hist.length - 1] === goal.trim())
+            return;
+        hist.push(goal.trim());
+        if (hist.length > MAX_GOAL_HISTORY)
+            hist.shift();
+        this.sessionGoalHistory.set(sessionId, hist);
+    }
+    /** Get goal history for a session (oldest first, most recent last). */
+    getGoalHistory(sessionId) {
+        return this.sessionGoalHistory.get(sessionId) ?? [];
+    }
+    /** Restore a previous goal (1 = most recent, 2 = two back, etc.). Returns the goal string or null. */
+    getPreviousGoal(sessionId, nBack = 1) {
+        const hist = this.sessionGoalHistory.get(sessionId) ?? [];
+        const idx = hist.length - nBack;
+        return idx >= 0 ? hist[idx] : null;
+    }
+    // ── Session multi-tags ───────────────────────────────────────────────────
+    /**
+     * Set tags for a session (replaces existing). Pass empty array to clear.
+     * Returns true if session found.
+     */
+    setSessionTags(sessionIdOrIndex, tags) {
+        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 false;
+        if (tags.length === 0) {
+            this.sessionTags.delete(sessionId);
+        }
+        else {
+            const tagSet = new Set(tags.map((t) => t.trim().toLowerCase()).filter(Boolean));
+            this.sessionTags.set(sessionId, tagSet);
+        }
+        if (this.active)
+            this.paintSessions();
+        return true;
+    }
+    /** Get tags for a session ID (empty set if none). */
+    getSessionTags(id) {
+        return this.sessionTags.get(id) ?? new Set();
+    }
+    /** Return all session tags (id → tag set). */
+    getAllSessionTags() {
+        return this.sessionTags;
+    }
+    /** Return sessions that have a given tag. */
+    getSessionsWithTag(tag) {
+        const lower = tag.toLowerCase();
+        return this.sessions.filter((s) => this.sessionTags.get(s.id)?.has(lower));
+    }
+    /** Restore session tags from persisted prefs. */
+    restoreSessionTags(tags) {
+        this.sessionTags.clear();
+        for (const [id, arr] of Object.entries(tags)) {
+            if (arr.length > 0)
+                this.sessionTags.set(id, new Set(arr));
+        }
+    }
+    /** 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.
@@ -876,6 +1136,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();
@@ -1186,6 +1467,9 @@ export class TUI {
             if (shouldMuteEntry(entry, this.mutedIds)) {
                 // silently skip display — entry is in buffer for scroll-back if unmuted later
             }
+            else if (isSuppressedEntry(entry, this.suppressedTags)) {
+                // suppressed tag (e.g. /mute-errors) — silently buffered, hidden from display
+            }
             else if (this.filterTag && !matchesTagFilter(entry, this.filterTag)) {
                 // tag filter active: silently skip non-matching entries
             }
@@ -1225,20 +1509,26 @@ export class TUI {
             this.activityBuffer = this.activityBuffer.slice(-this.maxActivity);
         }
     }
+    /** Apply all active display filters to an entry array: mute, suppress, tag, search. */
+    applyDisplayFilters(entries) {
+        let out = entries;
+        if (this.mutedIds.size > 0)
+            out = out.filter((e) => !shouldMuteEntry(e, this.mutedIds));
+        if (this.suppressedTags.size > 0)
+            out = out.filter((e) => !isSuppressedEntry(e, this.suppressedTags));
+        if (this.filterTag)
+            out = out.filter((e) => matchesTagFilter(e, this.filterTag));
+        if (this.searchPattern)
+            out = out.filter((e) => matchesSearch(e, this.searchPattern));
+        return out;
+    }
     // ── 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));
-        let filtered = this.mutedIds.size > 0
-            ? this.activityBuffer.filter((e) => !shouldMuteEntry(e, this.mutedIds))
-            : this.activityBuffer;
-        if (this.filterTag)
-            filtered = filtered.filter((e) => matchesTagFilter(e, this.filterTag));
-        const entryCount = this.searchPattern
-            ? filtered.filter((e) => matchesSearch(e, this.searchPattern)).length
-            : filtered.length;
+        const entryCount = this.applyDisplayFilters(this.activityBuffer).length;
         const maxOffset = Math.max(0, entryCount - visibleLines);
         this.scrollOffset = Math.min(maxOffset, this.scrollOffset + n);
         this.repaintActivityRegion();
@@ -1260,14 +1550,7 @@ export class TUI {
         if (!this.active)
             return;
         const visibleLines = this.scrollBottom - this.scrollTop + 1;
-        let filtered = this.mutedIds.size > 0
-            ? this.activityBuffer.filter((e) => !shouldMuteEntry(e, this.mutedIds))
-            : this.activityBuffer;
-        if (this.filterTag)
-            filtered = filtered.filter((e) => matchesTagFilter(e, this.filterTag));
-        const entryCount = this.searchPattern
-            ? filtered.filter((e) => matchesSearch(e, this.searchPattern)).length
-            : filtered.length;
+        const entryCount = this.applyDisplayFilters(this.activityBuffer).length;
         this.scrollOffset = Math.max(0, entryCount - visibleLines);
         this.repaintActivityRegion();
         this.paintSeparator();
@@ -1510,7 +1793,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 +
@@ -1567,7 +1855,11 @@ export class TUI {
                     watchdogThresholdMs: this.watchdogThresholdMs,
                 }));
             }
-            const compactRows = formatCompactRows(visibleSessions, innerWidth - 1, this.pinnedIds, this.mutedIds, noteIdSet, compactHealthScores);
+            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);
@@ -1602,6 +1894,9 @@ export class TUI {
                 });
                 const healthBadge = formatHealthBadge(healthScore);
                 const displayName = this.sessionAliases.get(s.id);
+                const sTags = this.sessionTags.get(s.id);
+                const tagsBadge = sTags && sTags.size > 0 ? `${formatSessionTagsBadge(sTags)} ` : "";
+                const tagsBadgeWidth = sTags && sTags.size > 0 ? stripAnsiForLen(formatSessionTagsBadge(sTags)) + 1 : 0;
                 const muteBadge = muted ? formatMuteBadge(this.mutedEntryCounts.get(s.id) ?? 0) : "";
                 const muteBadgeWidth = muted ? String(Math.min(this.mutedEntryCounts.get(s.id) ?? 0, 9999)).length + 2 : 0; // "(N)" visible chars, 0 when count is 0
                 const actualBadgeWidth = (this.mutedEntryCounts.get(s.id) ?? 0) > 0 ? muteBadgeWidth + 1 : 0; // +1 for trailing space
@@ -1611,9 +1906,9 @@ export class TUI {
                 const note = noted ? `${TEAL}${NOTE_ICON}${RESET} ` : "";
                 const groupBadge = group ? `${formatGroupBadge(group)} ` : "";
                 const badgeSuffix = muteBadge ? `${muteBadge} ` : "";
-                const iconsWidth = (pinned ? 2 : 0) + (muted ? 2 : 0) + (noted ? 2 : 0) + actualBadgeWidth + groupBadgeWidth;
+                const iconsWidth = (pinned ? 2 : 0) + (muted ? 2 : 0) + (noted ? 2 : 0) + actualBadgeWidth + groupBadgeWidth + tagsBadgeWidth;
                 const cardWidth = innerWidth - 1 - iconsWidth;
-                const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge || undefined, displayName)}`;
+                const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${tagsBadge}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge || undefined, displayName)}`;
                 const padded = padBoxLineHover(line, this.cols, isHovered);
                 process.stderr.write(moveTo(startRow + 1 + i, 1) + CLEAR_LINE + padded);
             }
@@ -1684,13 +1979,14 @@ export class TUI {
     paintSeparator() {
         const prefix = `${BOX.h}${BOX.h} activity `;
         let hints;
+        // suppressed-errors indicator when active (shown before other filters)
+        const suppressedSuffix = this.suppressedTags.size > 0
+            ? `  ${DIM}${MUTE_ICON}errors${RESET}` : "";
         if (this.filterTag) {
             // tag filter takes precedence in the separator display
-            let source = this.mutedIds.size > 0
-                ? this.activityBuffer.filter((e) => !shouldMuteEntry(e, this.mutedIds))
-                : this.activityBuffer;
+            const source = this.applyDisplayFilters(this.activityBuffer.filter((e) => !isSuppressedEntry(e, this.suppressedTags)));
             const matchCount = source.filter((e) => matchesTagFilter(e, this.filterTag)).length;
-            hints = formatTagFilterIndicator(this.filterTag, matchCount, source.length);
+            hints = formatTagFilterIndicator(this.filterTag, matchCount, source.length) + suppressedSuffix;
         }
         else if (this.searchPattern) {
             const filtered = this.activityBuffer.filter((e) => matchesSearch(e, this.searchPattern));
@@ -1722,15 +2018,8 @@ export class TUI {
     }
     repaintActivityRegion() {
         const visibleLines = this.scrollBottom - this.scrollTop + 1;
-        // filter pipeline: muted → tag → search
-        let source = this.mutedIds.size > 0
-            ? this.activityBuffer.filter((e) => !shouldMuteEntry(e, this.mutedIds))
-            : this.activityBuffer;
-        if (this.filterTag)
-            source = source.filter((e) => matchesTagFilter(e, this.filterTag));
-        if (this.searchPattern) {
-            source = source.filter((e) => matchesSearch(e, this.searchPattern));
-        }
+        // filter pipeline: muted → suppressed → tag → search
+        const source = this.applyDisplayFilters(this.activityBuffer);
         const { start, end } = computeScrollSlice(source.length, visibleLines, this.scrollOffset);
         const entries = source.slice(start, end);
         for (let i = 0; i < visibleLines; i++) {

package/package.json

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