aoaoe 0.149.0 → 0.156.0

package/dist/index.js

@@ -16,7 +16,7 @@ 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, buildSessionStats, formatSessionStatsLines, formatStatsJson, validateSessionTag, validateColorName, computeErrorTrend, parseQuietHoursRange, computeCostSummary, formatSessionReport, formatQuietStatus, formatSessionAge } 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, validateColorName, computeErrorTrend, parseQuietHoursRange, computeCostSummary, formatSessionReport, formatQuietStatus, formatSessionAge, formatHealthTrendChart, isOverBudget, DRAIN_ICON } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
@@ -1023,6 +1023,54 @@ async function main() {
             tui.log("system", `quiet hours: ${specs.join(", ")} — watchdog+burn alerts suppressed`);
             persistPrefs();
         });
+        // wire /flap-log
+        input.onFlapLog(() => {
+            const log = tui.getFlapLog();
+            if (log.length === 0) {
+                tui.log("system", "flap-log: no flap events recorded");
+                return;
+            }
+            tui.log("system", `flap-log: ${log.length} event${log.length !== 1 ? "s" : ""}:`);
+            for (const e of log.slice(-20)) {
+                const time = new Date(e.ts).toLocaleTimeString();
+                tui.log("system", `  ${time}  ${e.title}: ${e.count} changes in window`);
+            }
+        });
+        // wire /drain and /undrain
+        input.onDrain((target, drain) => {
+            const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;
+            const ok = drain ? tui.drainSession(num ?? target) : tui.undrainSession(num ?? target);
+            if (ok) {
+                tui.log("system", `${drain ? "drain" : "undrain"}: ${target} ${drain ? `marked draining (${DRAIN_ICON})` : "restored"}`);
+            }
+            else {
+                tui.log("system", `session not found: ${target}`);
+            }
+        });
+        // wire /export-all bulk export
+        input.onExportAll(() => {
+            const sessions = tui.getSessions();
+            if (sessions.length === 0) {
+                tui.log("system", "export-all: no sessions");
+                return;
+            }
+            const now = Date.now();
+            const ts = new Date(now).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+            const dir = join(homedir(), ".aoaoe");
+            try {
+                mkdirSync(dir, { recursive: true });
+                // snapshot JSON
+                const snapData = buildSnapshotData(sessions, tui.getAllGroups(), tui.getAllNotes(), tui.getAllFirstSeen(), tui.getSessionErrorCounts(), tui.getAllBurnRates(now), pkg ?? "dev", now);
+                writeFileSync(join(dir, `snapshot-${ts}.json`), formatSnapshotJson(snapData), "utf-8");
+                // stats JSON
+                const statEntries = buildSessionStats(sessions, tui.getSessionErrorCounts(), tui.getAllBurnRates(now), tui.getAllFirstSeen(), tui.getAllLastChangeAt(), tui.getAllHealthScores(now), tui.getAllSessionAliases(), now, new Map(sessions.map((s) => [s.id, tui.getSessionErrorTimestamps(s.id)])), tui.getAllSessionCosts(), new Map(sessions.map((s) => [s.id, tui.getSessionHealthHistory(s.id)])));
+                writeFileSync(join(dir, `stats-${ts}.json`), formatStatsJson(statEntries, pkg ?? "dev", now), "utf-8");
+                tui.log("system", `export-all: snapshot + stats saved to ~/.aoaoe/ (${sessions.length} sessions)`);
+            }
+            catch (err) {
+                tui.log("error", `export-all failed: ${err}`);
+            }
+        });
         // wire /budget cost alerts
         input.onBudget((target, budgetUSD) => {
             if (budgetUSD === null) {
@@ -1062,6 +1110,84 @@ async function main() {
             }
             tui.log("system", `${action}-all: sent to ${count} session${count !== 1 ? "s" : ""}`);
         });
+        // wire /health-trend
+        input.onHealthTrend((target, height) => {
+            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 hist = tui.getSessionHealthHistory(session.id);
+            const lines = formatHealthTrendChart(hist, session.title, height);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /alert-mute
+        input.onAlertMute((pattern) => {
+            if (pattern === null) {
+                // null = "clear" keyword
+                tui.clearAlertMutePatterns();
+                tui.log("system", "alert-mute: all patterns cleared");
+                return;
+            }
+            if (!pattern) {
+                // empty = list patterns
+                const pats = tui.getAlertMutePatterns();
+                if (pats.size === 0) {
+                    tui.log("system", "alert-mute: no patterns set — use /alert-mute <text> to suppress");
+                }
+                else {
+                    tui.log("system", `alert-mute: ${pats.size} pattern${pats.size !== 1 ? "s" : ""}:`);
+                    for (const p of pats)
+                        tui.log("system", `  "${p}"`);
+                }
+                return;
+            }
+            tui.addAlertMutePattern(pattern);
+            tui.log("system", `alert-mute: added "${pattern}" — matching alerts hidden from /alert-log`);
+        });
+        // wire /budgets list
+        input.onBudgetsList(() => {
+            const global = tui.getGlobalBudget();
+            const perSession = tui.getAllSessionBudgets();
+            if (global === null && perSession.size === 0) {
+                tui.log("system", "budgets: none set — use /budget $N (global) or /budget <N> $N (per-session)");
+                return;
+            }
+            if (global !== null)
+                tui.log("system", `  global: $${global.toFixed(2)}`);
+            const sessions = tui.getSessions();
+            for (const [id, budget] of perSession) {
+                const s = sessions.find((s) => s.id === id);
+                const label = s?.title ?? id.slice(0, 8);
+                tui.log("system", `  ${label}: $${budget.toFixed(2)}`);
+            }
+        });
+        // wire /budget-status
+        input.onBudgetStatus(() => {
+            const sessions = tui.getSessions();
+            const costs = tui.getAllSessionCosts();
+            const global = tui.getGlobalBudget();
+            const perSession = tui.getAllSessionBudgets();
+            let shown = 0;
+            for (const s of sessions) {
+                const budget = perSession.get(s.id) ?? global;
+                const costStr = costs.get(s.id);
+                if (budget === null)
+                    continue;
+                const over = isOverBudget(costStr, budget);
+                const costLabel = costStr ?? "(no data)";
+                const status = over ? `OVER ($${budget.toFixed(2)} budget)` : `ok ($${budget.toFixed(2)} budget)`;
+                tui.log("system", `  ${s.title}: ${costLabel} — ${status}`);
+                shown++;
+            }
+            if (shown === 0)
+                tui.log("system", "budget-status: no sessions with budgets configured");
+        });
         // wire /quiet-status
         input.onQuietStatus(() => {
             const { active, message } = formatQuietStatus(tui.getQuietHours());

package/dist/input.d.ts

@@ -58,6 +58,13 @@ export type QuietStatusHandler = () => void;
 export type AlertLogHandler = (count: number) => void;
 export type BudgetHandler = (target: string | null, budgetUSD: number | null) => void;
 export type BulkControlHandler = (action: "pause" | "resume") => void;
+export type HealthTrendHandler = (target: string, height: number) => void;
+export type AlertMuteHandler = (pattern: string | null) => void;
+export type BudgetsListHandler = () => void;
+export type BudgetStatusHandler = () => void;
+export type FlapLogHandler = () => void;
+export type DrainHandler = (target: string, drain: boolean) => void;
+export type ExportAllHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -138,6 +145,13 @@ export declare class InputReader {
     private alertLogHandler;
     private budgetHandler;
     private bulkControlHandler;
+    private healthTrendHandler;
+    private alertMuteHandler;
+    private budgetsListHandler;
+    private budgetStatusHandler;
+    private flapLogHandler;
+    private drainHandler;
+    private exportAllHandler;
     private aliases;
     private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
@@ -201,6 +215,13 @@ export declare class InputReader {
     onAlertLog(handler: AlertLogHandler): void;
     onBudget(handler: BudgetHandler): void;
     onBulkControl(handler: BulkControlHandler): void;
+    onHealthTrend(handler: HealthTrendHandler): void;
+    onAlertMute(handler: AlertMuteHandler): void;
+    onBudgetsList(handler: BudgetsListHandler): void;
+    onBudgetStatus(handler: BudgetStatusHandler): void;
+    onFlapLog(handler: FlapLogHandler): void;
+    onDrain(handler: DrainHandler): void;
+    onExportAll(handler: ExportAllHandler): void;
     /** Set aliases from persisted prefs. */
     setAliases(aliases: Record<string, string>): void;
     /** Get current aliases as a plain object. */

package/dist/input.js

@@ -91,6 +91,13 @@ export class InputReader {
     alertLogHandler = null;
     budgetHandler = null;
     bulkControlHandler = null;
+    healthTrendHandler = null;
+    alertMuteHandler = null;
+    budgetsListHandler = null;
+    budgetStatusHandler = null;
+    flapLogHandler = null;
+    drainHandler = null;
+    exportAllHandler = null;
     aliases = new Map(); // /shortcut → /full command
     mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
@@ -307,6 +314,13 @@ export class InputReader {
     onAlertLog(handler) { this.alertLogHandler = handler; }
     onBudget(handler) { this.budgetHandler = handler; }
     onBulkControl(handler) { this.bulkControlHandler = handler; }
+    onHealthTrend(handler) { this.healthTrendHandler = handler; }
+    onAlertMute(handler) { this.alertMuteHandler = handler; }
+    onBudgetsList(handler) { this.budgetsListHandler = handler; }
+    onBudgetStatus(handler) { this.budgetStatusHandler = handler; }
+    onFlapLog(handler) { this.flapLogHandler = handler; }
+    onDrain(handler) { this.drainHandler = handler; }
+    onExportAll(handler) { this.exportAllHandler = handler; }
     /** Set aliases from persisted prefs. */
     setAliases(aliases) {
         this.aliases.clear();
@@ -572,8 +586,16 @@ ${BOLD}navigation:${RESET}
   /budget [N] [$]    set cost budget: /budget 1 2.50 (session), /budget 2.50 (global), /budget clear
   /pause-all         send interrupt to all sessions
   /resume-all        send resume to all sessions
-  /alert-log [N]     show last N auto-generated alerts (burn-rate/watchdog/ceiling; default 20)
-  /history-stats     show aggregate statistics from persisted activity history
+   /alert-log [N]     show last N auto-generated alerts (burn-rate/watchdog/ceiling; default 20)
+   /alert-mute [pat]  suppress alerts containing pattern; no arg = list; clear = remove all
+   /health-trend N    show ASCII health score chart for session N [height]
+   /budgets           list all active cost budgets
+   /budget-status     show which sessions are over or under budget
+   /flap-log          show sessions recently flagged as flapping
+   /drain N           mark session N as draining (supervisor will skip it)
+   /undrain N         remove drain mark from session N
+   /export-all        bulk export snapshot + stats JSON for all sessions
+   /history-stats     show aggregate statistics from persisted activity history
   /cost-summary      show total estimated spend across all sessions
   /session-report N  generate full markdown report for a session → ~/.aoaoe/report-<name>-<ts>.md
   /clip [N]          copy last N activity entries to clipboard (default 20)
@@ -1168,6 +1190,80 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}resume-all not available${RESET}`);
                 break;
+            case "/health-trend": {
+                const htArgs = line.slice("/health-trend".length).trim().split(/\s+/).filter(Boolean);
+                const htTarget = htArgs[0] ?? "";
+                const htHeight = htArgs[1] ? parseInt(htArgs[1], 10) : 6;
+                if (!htTarget) {
+                    console.error(`${DIM}usage: /health-trend <N|name> [height]${RESET}`);
+                    break;
+                }
+                if (this.healthTrendHandler)
+                    this.healthTrendHandler(htTarget, isNaN(htHeight) || htHeight < 2 ? 6 : Math.min(htHeight, 20));
+                else
+                    console.error(`${DIM}health-trend not available${RESET}`);
+                break;
+            }
+            case "/alert-mute": {
+                const amArg = line.slice("/alert-mute".length).trim();
+                if (this.alertMuteHandler) {
+                    if (amArg.toLowerCase() === "clear")
+                        this.alertMuteHandler(null);
+                    else
+                        this.alertMuteHandler(amArg || null);
+                }
+                else
+                    console.error(`${DIM}alert-mute not available${RESET}`);
+                break;
+            }
+            case "/budgets":
+                if (this.budgetsListHandler)
+                    this.budgetsListHandler();
+                else
+                    console.error(`${DIM}budgets not available${RESET}`);
+                break;
+            case "/flap-log":
+                if (this.flapLogHandler)
+                    this.flapLogHandler();
+                else
+                    console.error(`${DIM}flap-log not available${RESET}`);
+                break;
+            case "/drain": {
+                const drainArg = line.slice("/drain".length).trim();
+                if (!drainArg) {
+                    console.error(`${DIM}usage: /drain <N|name>${RESET}`);
+                    break;
+                }
+                if (this.drainHandler)
+                    this.drainHandler(drainArg, true);
+                else
+                    console.error(`${DIM}drain not available${RESET}`);
+                break;
+            }
+            case "/undrain": {
+                const undrainArg = line.slice("/undrain".length).trim();
+                if (!undrainArg) {
+                    console.error(`${DIM}usage: /undrain <N|name>${RESET}`);
+                    break;
+                }
+                if (this.drainHandler)
+                    this.drainHandler(undrainArg, false);
+                else
+                    console.error(`${DIM}undrain not available${RESET}`);
+                break;
+            }
+            case "/export-all":
+                if (this.exportAllHandler)
+                    this.exportAllHandler();
+                else
+                    console.error(`${DIM}export-all not available${RESET}`);
+                break;
+            case "/budget-status":
+                if (this.budgetStatusHandler)
+                    this.budgetStatusHandler();
+                else
+                    console.error(`${DIM}budget-status not available${RESET}`);
+                break;
             case "/quiet-status":
                 if (this.quietStatusHandler)
                     this.quietStatusHandler();

package/dist/tui.d.ts

@@ -137,6 +137,36 @@ export interface HealthSnapshot {
  * Each bucket covers 1/5 of the history window. Color: LIME/AMBER/ROSE by value.
  */
 export declare function formatHealthSparkline(history: readonly HealthSnapshot[], now?: number): string;
+/**
+ * Format health score history as a multi-line ASCII bar chart.
+ * Returns an array of lines suitable for logging to the activity area.
+ * Each column is one snapshot, ordered oldest→newest.
+ * Bar height 0–8 rows. Color: LIME/AMBER/ROSE.
+ */
+export declare function formatHealthTrendChart(history: readonly HealthSnapshot[], title: string, height?: number): string[];
+/** Status change entry for flap detection. */
+export interface StatusChange {
+    status: string;
+    ts: number;
+}
+/** Max status change entries stored per session. */
+export declare const MAX_STATUS_HISTORY = 30;
+/** Flap detection window: check for oscillation in the last N minutes. */
+export declare const FLAP_WINDOW_MS: number;
+/** Min status changes in window to be considered flapping. */
+export declare const FLAP_THRESHOLD = 5;
+/**
+ * Detect if a session is "flapping" — rapidly oscillating between statuses.
+ * Returns true when there are >= FLAP_THRESHOLD status changes in FLAP_WINDOW_MS.
+ */
+export declare function isFlapping(changes: readonly StatusChange[], now?: number, windowMs?: number, threshold?: number): boolean;
+/** Drain icon shown in session cards for draining sessions. */
+export declare const DRAIN_ICON = "\u21E3";
+/**
+ * Check if an alert text matches any suppressed pattern (case-insensitive substring).
+ * Returns true when the alert should be hidden.
+ */
+export declare function isAlertMuted(text: string, patterns: ReadonlySet<string>): boolean;
 /**
  * Parse a cost string like "$3.42" → 3.42, or null if unparseable.
  */
@@ -415,6 +445,12 @@ export declare class TUI {
     private sessionBudgets;
     private globalBudget;
     private budgetAlerted;
+    private sessionStatusHistory;
+    private prevSessionStatus;
+    private flapAlerted;
+    private alertMutePatterns;
+    private drainingIds;
+    private flapLog;
     private viewMode;
     private drilldownSessionId;
     private sessionOutputs;
@@ -558,8 +594,35 @@ export declare class TUI {
     getAllSessionBudgets(): ReadonlyMap<string, number>;
     /** Return health history for a session (for sparkline). */
     getSessionHealthHistory(id: string): readonly HealthSnapshot[];
-    /** Return all alert log entries (last 100 "status" tag entries). */
-    getAlertLog(): readonly ActivityEntry[];
+    /** Mark a session as draining (by index, ID, or title). Returns true if found. */
+    drainSession(sessionIdOrIndex: string | number): boolean;
+    /** Remove drain mark from a session. Returns true if it was draining. */
+    undrainSession(sessionIdOrIndex: string | number): boolean;
+    /** Check if a session is draining. */
+    isDraining(id: string): boolean;
+    /** Return all draining session IDs (for reasoner prompt and display). */
+    getDrainingIds(): ReadonlySet<string>;
+    /** Return recent flap events (newest last). */
+    getFlapLog(): readonly {
+        sessionId: string;
+        title: string;
+        ts: number;
+        count: number;
+    }[];
+    /** Return all alert log entries (last 100 "status" tag entries), filtered by mute patterns. */
+    getAlertLog(includeAll?: boolean): readonly ActivityEntry[];
+    /** Return status change history for a session. */
+    getSessionStatusHistory(id: string): readonly StatusChange[];
+    /** Check if a session is currently flapping. */
+    isSessionFlapping(id: string, now?: number): boolean;
+    /** Add a pattern to suppress from alert log display. */
+    addAlertMutePattern(pattern: string): void;
+    /** Remove a pattern from alert mute list. Returns true if it was present. */
+    removeAlertMutePattern(pattern: string): boolean;
+    /** Clear all alert mute patterns. */
+    clearAlertMutePatterns(): void;
+    /** Return all alert mute patterns (for display/persistence). */
+    getAlertMutePatterns(): ReadonlySet<string>;
     /** Get the latest cost string for a session (or undefined). */
     getSessionCost(id: string): string | undefined;
     /** Return all session costs (for /stats). */

package/dist/tui.js

@@ -428,6 +428,77 @@ export function formatHealthSparkline(history, now) {
         return `${color}${SPARK_BLOCKS[Math.min(SPARK_BLOCKS.length - 1, Math.floor(score / 100 * (SPARK_BLOCKS.length - 1)))]}${RESET}`;
     }).join("");
 }
+// ── Health trend chart (pure, exported for testing) ───────────────────────────
+/**
+ * Format health score history as a multi-line ASCII bar chart.
+ * Returns an array of lines suitable for logging to the activity area.
+ * Each column is one snapshot, ordered oldest→newest.
+ * Bar height 0–8 rows. Color: LIME/AMBER/ROSE.
+ */
+export function formatHealthTrendChart(history, title, height = 6) {
+    if (history.length === 0)
+        return [`  ${title}: no health history`];
+    const MAX_COLS = 40;
+    const samples = history.slice(-MAX_COLS);
+    const lines = [];
+    // header
+    const minScore = Math.min(...samples.map((h) => h.score));
+    const maxScore = Math.max(...samples.map((h) => h.score));
+    lines.push(`  ${DIM}${title}${RESET} health trend (${samples.length} samples, ${minScore}–${maxScore})`);
+    // chart rows (top = high score, bottom = low score)
+    for (let row = height - 1; row >= 0; row--) {
+        const threshold = Math.round(((row + 1) / height) * 100);
+        const prevThreshold = Math.round((row / height) * 100);
+        const yLabel = row === height - 1 ? "100" : row === 0 ? "  0" : `   `;
+        const bar = samples.map((h) => {
+            if (h.score >= threshold) {
+                const color = h.score >= HEALTH_GOOD ? LIME : h.score >= HEALTH_WARN ? AMBER : ROSE;
+                return `${color}█${RESET}`;
+            }
+            if (h.score >= prevThreshold) {
+                const color = h.score >= HEALTH_GOOD ? LIME : h.score >= HEALTH_WARN ? AMBER : ROSE;
+                return `${color}▄${RESET}`;
+            }
+            return `${DIM}·${RESET}`;
+        }).join("");
+        lines.push(`  ${DIM}${yLabel}${RESET}│${bar}`);
+    }
+    lines.push(`     └${"─".repeat(samples.length)}`);
+    return lines;
+}
+/** Max status change entries stored per session. */
+export const MAX_STATUS_HISTORY = 30;
+/** Flap detection window: check for oscillation in the last N minutes. */
+export const FLAP_WINDOW_MS = 10 * 60_000;
+/** Min status changes in window to be considered flapping. */
+export const FLAP_THRESHOLD = 5;
+/**
+ * Detect if a session is "flapping" — rapidly oscillating between statuses.
+ * Returns true when there are >= FLAP_THRESHOLD status changes in FLAP_WINDOW_MS.
+ */
+export function isFlapping(changes, now, windowMs = FLAP_WINDOW_MS, threshold = FLAP_THRESHOLD) {
+    const cutoff = (now ?? Date.now()) - windowMs;
+    const recent = changes.filter((c) => c.ts >= cutoff);
+    return recent.length >= threshold;
+}
+// ── Session drain mode helpers ────────────────────────────────────────────────
+/** Drain icon shown in session cards for draining sessions. */
+export const DRAIN_ICON = "⇣";
+// ── Alert mute patterns (pure, exported for testing) ──────────────────────────
+/**
+ * Check if an alert text matches any suppressed pattern (case-insensitive substring).
+ * Returns true when the alert should be hidden.
+ */
+export function isAlertMuted(text, patterns) {
+    if (patterns.size === 0)
+        return false;
+    const lower = text.toLowerCase();
+    for (const p of patterns) {
+        if (lower.includes(p.toLowerCase()))
+            return true;
+    }
+    return false;
+}
 // ── Cost summary (pure, exported for testing) ────────────────────────────────
 /**
  * Parse a cost string like "$3.42" → 3.42, or null if unparseable.
@@ -738,7 +809,8 @@ export const BUILTIN_COMMANDS = new Set([
     "/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", "/tag-filter", "/find", "/reset-health", "/timeline", "/color", "/clear-history",
     "/duplicate", "/color-all", "/quiet-hours", "/quiet-status", "/history-stats", "/cost-summary", "/session-report", "/alert-log",
-    "/budget", "/pause-all", "/resume-all",
+    "/budget", "/budgets", "/budget-status", "/pause-all", "/resume-all",
+    "/health-trend", "/alert-mute", "/flap-log", "/drain", "/undrain", "/export-all",
 ]);
 /** Resolve a slash command through the alias map. Returns the expanded command or the original. */
 export function resolveAlias(line, aliases) {
@@ -1015,6 +1087,12 @@ export class TUI {
     sessionBudgets = new Map(); // session ID → USD budget
     globalBudget = null; // global fallback budget in USD
     budgetAlerted = new Map(); // session ID → epoch ms of last budget alert
+    sessionStatusHistory = new Map(); // session ID → status change log
+    prevSessionStatus = new Map(); // session ID → last known status (for change detection)
+    flapAlerted = new Map(); // session ID → epoch ms of last flap alert
+    alertMutePatterns = new Set(); // substrings to hide from /alert-log display
+    drainingIds = new Set(); // session IDs marked as draining (skip by reasoner)
+    flapLog = []; // recent flap events
     // drill-down mode: show a single session's full output
     viewMode = "overview";
     drilldownSessionId = null;
@@ -1527,9 +1605,87 @@ export class TUI {
     getSessionHealthHistory(id) {
         return this.sessionHealthHistory.get(id) ?? [];
     }
-    /** Return all alert log entries (last 100 "status" tag entries). */
-    getAlertLog() {
-        return this.alertLog;
+    // ── Session drain mode ───────────────────────────────────────────────────
+    /** Mark a session as draining (by index, ID, or title). Returns true if found. */
+    drainSession(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 false;
+        this.drainingIds.add(sessionId);
+        if (this.active)
+            this.paintSessions();
+        return true;
+    }
+    /** Remove drain mark from a session. Returns true if it was draining. */
+    undrainSession(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 false;
+        const had = this.drainingIds.delete(sessionId);
+        if (had && this.active)
+            this.paintSessions();
+        return had;
+    }
+    /** Check if a session is draining. */
+    isDraining(id) {
+        return this.drainingIds.has(id);
+    }
+    /** Return all draining session IDs (for reasoner prompt and display). */
+    getDrainingIds() {
+        return this.drainingIds;
+    }
+    // ── Flap log ─────────────────────────────────────────────────────────────
+    /** Return recent flap events (newest last). */
+    getFlapLog() {
+        return this.flapLog;
+    }
+    /** Return all alert log entries (last 100 "status" tag entries), filtered by mute patterns. */
+    getAlertLog(includeAll = false) {
+        if (includeAll || this.alertMutePatterns.size === 0)
+            return this.alertLog;
+        return this.alertLog.filter((e) => !isAlertMuted(e.text, this.alertMutePatterns));
+    }
+    /** Return status change history for a session. */
+    getSessionStatusHistory(id) {
+        return this.sessionStatusHistory.get(id) ?? [];
+    }
+    /** Check if a session is currently flapping. */
+    isSessionFlapping(id, now) {
+        const hist = this.sessionStatusHistory.get(id);
+        return hist ? isFlapping(hist, now) : false;
+    }
+    // ── Alert mute patterns ──────────────────────────────────────────────────
+    /** Add a pattern to suppress from alert log display. */
+    addAlertMutePattern(pattern) {
+        this.alertMutePatterns.add(pattern.toLowerCase().trim());
+    }
+    /** Remove a pattern from alert mute list. Returns true if it was present. */
+    removeAlertMutePattern(pattern) {
+        return this.alertMutePatterns.delete(pattern.toLowerCase().trim());
+    }
+    /** Clear all alert mute patterns. */
+    clearAlertMutePatterns() {
+        this.alertMutePatterns.clear();
+    }
+    /** Return all alert mute patterns (for display/persistence). */
+    getAlertMutePatterns() {
+        return this.alertMutePatterns;
     }
     /** Get the latest cost string for a session (or undefined). */
     getSessionCost(id) {
@@ -1849,6 +2005,28 @@ export class TUI {
             for (const s of opts.sessions) {
                 if (!this.sessionFirstSeen.has(s.id))
                     this.sessionFirstSeen.set(s.id, now);
+                // track status changes for flap detection
+                const prevStatus = this.prevSessionStatus.get(s.id);
+                if (prevStatus !== undefined && prevStatus !== s.status) {
+                    const statusHist = this.sessionStatusHistory.get(s.id) ?? [];
+                    statusHist.push({ status: s.status, ts: now });
+                    if (statusHist.length > MAX_STATUS_HISTORY)
+                        statusHist.shift();
+                    this.sessionStatusHistory.set(s.id, statusHist);
+                    // check for flapping
+                    if (isFlapping(statusHist, now) && !quietNow) {
+                        const lastFlapAlert = this.flapAlerted.get(s.id) ?? 0;
+                        if (now - lastFlapAlert >= 5 * 60_000) {
+                            this.flapAlerted.set(s.id, now);
+                            const flapCount = statusHist.filter((c) => c.ts >= now - FLAP_WINDOW_MS).length;
+                            this.flapLog.push({ sessionId: s.id, title: s.title, ts: now, count: flapCount });
+                            if (this.flapLog.length > 50)
+                                this.flapLog.shift();
+                            this.log("status", `flap: ${s.title} is oscillating rapidly (${flapCount} status changes in ${Math.round(FLAP_WINDOW_MS / 60_000)}m)`, s.id);
+                        }
+                    }
+                }
+                this.prevSessionStatus.set(s.id, s.status);
                 const prev = this.prevLastActivity.get(s.id);
                 if (s.lastActivity !== undefined && s.lastActivity !== prev) {
                     this.lastChangeAt.set(s.id, now);
@@ -2444,6 +2622,8 @@ export class TUI {
                 const colorName = this.sessionColors.get(s.id);
                 const colorDot = colorName ? formatColorDot(colorName) : "";
                 const colorDotWidth = colorName ? 2 : 0; // dot + space
+                const draining = this.drainingIds.has(s.id);
+                const drainIcon = draining ? `${DIM}${DRAIN_ICON}${RESET} ` : "";
                 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
@@ -2453,10 +2633,10 @@ 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 + tagsBadgeWidth + colorDotWidth;
+                const iconsWidth = (pinned ? 2 : 0) + (muted ? 2 : 0) + (noted ? 2 : 0) + actualBadgeWidth + groupBadgeWidth + tagsBadgeWidth + colorDotWidth + (draining ? 2 : 0);
                 const cardWidth = innerWidth - 1 - iconsWidth;
                 const cardAge = s.createdAt ? formatSessionAge(s.createdAt, nowMs) : undefined;
-                const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${tagsBadge}${colorDot}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge || undefined, displayName, cardAge || undefined)}`;
+                const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${tagsBadge}${colorDot}${drainIcon}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge || undefined, displayName, cardAge || undefined)}`;
                 const padded = padBoxLineHover(line, this.cols, isHovered);
                 process.stderr.write(moveTo(startRow + 1 + i, 1) + CLEAR_LINE + padded);
             }
@@ -2524,10 +2704,12 @@ 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 + tagsBadgeWidth2 + colorDotWidth2;
+        const draining2 = this.drainingIds.has(s.id);
+        const drainIcon2 = draining2 ? `${DIM}${DRAIN_ICON}${RESET} ` : "";
+        const iconsWidth = (pinned ? 2 : 0) + (muted ? 2 : 0) + (noted ? 2 : 0) + actualBadgeWidth + groupBadgeWidth + tagsBadgeWidth2 + colorDotWidth2 + (draining2 ? 2 : 0);
         const cardWidth = innerWidth - 1 - iconsWidth;
         const cardAge2 = s.createdAt ? formatSessionAge(s.createdAt, nowMs2) : undefined;
-        const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${tagsBadge2}${colorDot2}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge2 || undefined, displayName2, cardAge2 || undefined)}`;
+        const line = `${bg}${SLATE}${BOX.v}${RESET}${bg} ${pin}${mute}${badgeSuffix}${note}${groupBadge}${tagsBadge2}${colorDot2}${drainIcon2}${formatSessionCard(s, cardWidth, errSparkline || undefined, idleSinceMs, healthBadge2 || undefined, displayName2, cardAge2 || undefined)}`;
         const padded = padBoxLineHover(line, this.cols, isHovered);
         process.stderr.write(SAVE_CURSOR + moveTo(startRow + 1 + i, 1) + CLEAR_LINE + padded + RESTORE_CURSOR);
     }

package/package.json

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