aoaoe 0.132.0 → 0.139.0

package/dist/daemon-state.js

@@ -5,7 +5,7 @@ import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync, renameS
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { toDaemonState } from "./types.js";
-import { parseTasks, formatTaskList, parseContext } from "./task-parser.js";
+import { parseTasks, formatTaskList, parseContext, parseCost } from "./task-parser.js";
 // default state directory — overridable via setStateDir() for test isolation
 let AOAOE_DIR = join(homedir(), ".aoaoe");
 let STATE_FILE = join(AOAOE_DIR, "daemon-state.json");
@@ -52,6 +52,7 @@ const sessionTasks = new Map();
 const todoCache = new Map();
 // cache parsed context token usage for unchanged sessions
 const contextCache = new Map();
+const costCache = new Map();
 export function setSessionTask(sessionId, task) {
     // keep task text short for display
     sessionTasks.set(sessionId, task.length > 80 ? task.slice(0, 77) + "..." : task);
@@ -108,6 +109,10 @@ export function buildSessionStates(obs) {
         if (!currentIds.has(id))
             contextCache.delete(id);
     }
+    for (const id of costCache.keys()) {
+        if (!currentIds.has(id))
+            costCache.delete(id);
+    }
     // only re-parse TODO items for sessions that have new output
     const changedIds = new Set(obs.changes.map((c) => c.sessionId));
     return obs.sessions.map((snap) => {
@@ -126,18 +131,23 @@ export function buildSessionStates(obs) {
             todoSummary = todoCache.get(s.id);
         }
         let contextTokens;
+        let costStr;
         if (changedIds.has(s.id)) {
             contextTokens = parseContext(snap.output);
             contextCache.set(s.id, contextTokens);
+            costStr = parseCost(snap.output);
+            costCache.set(s.id, costStr);
         }
         else {
             contextTokens = contextCache.get(s.id);
+            costStr = costCache.get(s.id);
         }
         return {
             id: s.id,
             title: s.title,
             tool: s.tool,
             status: s.status,
+            path: snap.session.path,
             currentTask: sessionTasks.get(s.id),
             lastActivity: lastActivity && lastActivity.length > 100
                 ? lastActivity.slice(0, 97) + "..."
@@ -145,6 +155,7 @@ export function buildSessionStates(obs) {
             contextTokens,
             todoSummary,
             userActive: snap.userActive ?? false,
+            costStr,
         };
     });
 }

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, buildSessionStats, formatSessionStatsLines, formatStatsJson, validateSessionTag, validateColorName } 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 } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
-import { loadTuiHistory, searchHistory } from "./tui-history.js";
+import { loadTuiHistory, searchHistory, TUI_HISTORY_FILE, computeHistoryStats } 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";
@@ -194,6 +194,11 @@ async function main() {
             tui.restoreSessionTags(prefs.sessionTags);
         if (prefs.sessionColors)
             tui.restoreSessionColors(prefs.sessionColors);
+        if (prefs.quietHours && prefs.quietHours.length > 0) {
+            const ranges = prefs.quietHours.map(parseQuietHoursRange).filter(Boolean);
+            if (ranges.length > 0)
+                tui.setQuietHours(ranges);
+        }
     }
     const persistPrefs = () => {
         if (!tui)
@@ -223,6 +228,7 @@ async function main() {
             sessionAliases: aliasesObj,
             sessionTags: sTagsObj,
             sessionColors: sColorsObj,
+            quietHours: tui.getQuietHours().map(([s, e]) => `${s}-${e}`),
         });
     };
     if (!useTui) {
@@ -587,8 +593,11 @@ async function main() {
             for (const s of sorted) {
                 const up = firstSeen.has(s.id) ? formatUptime(now - firstSeen.get(s.id)) : "?";
                 const errCount = errors.get(s.id) ?? 0;
-                const errStr = errCount > 0 ? ` ${errCount}err` : "";
+                const errTs = tui.getSessionErrorTimestamps(s.id);
+                const errTrend = errTs.length > 0 ? (computeErrorTrend(errTs, now) === "rising" ? "↑" : computeErrorTrend(errTs, now) === "falling" ? "↓" : "") : "";
+                const errStr = errCount > 0 ? ` ${errCount}err${errTrend}` : "";
                 const ctxStr = s.contextTokens ? ` ${s.contextTokens}` : "";
+                const costStr = tui.getSessionCost(s.id) ? ` ${tui.getSessionCost(s.id)}` : "";
                 const note = notes.get(s.id);
                 const noteStr = note ? ` "${note}"` : "";
                 const group = groups.get(s.id);
@@ -597,7 +606,7 @@ async function main() {
                 const lastChange = lastChangeAt.get(s.id);
                 const idleStr = (lastChange && (s.status === "idle" || s.status === "stopped" || s.status === "done"))
                     ? ` idle ${formatUptime(now - lastChange)}` : "";
-                tui.log("system", `  ${s.title}${groupStr} — ${s.status} ${up}${ctxStr}${errStr}${idleStr}${noteStr}`);
+                tui.log("system", `  ${s.title}${groupStr} — ${s.status} ${up}${ctxStr}${costStr}${errStr}${idleStr}${noteStr}`);
             }
         });
         // wire /uptime listing
@@ -944,7 +953,7 @@ async function main() {
         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 entries = 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());
             const ts = new Date(now).toISOString().replace(/[:.]/g, "-").slice(0, 19);
             const dir = join(homedir(), ".aoaoe");
             const path = join(dir, `stats-${ts}.json`);
@@ -957,6 +966,87 @@ async function main() {
                 tui.log("error", `export-stats failed: ${err}`);
             }
         });
+        // wire /duplicate — clone a session
+        input.onDuplicate((target, newTitle) => {
+            const num = /^\d+$/.test(target) ? parseInt(target, 10) : undefined;
+            const args = tui.getDuplicateArgs(num ?? target, newTitle || undefined);
+            if (!args) {
+                tui.log("system", `duplicate failed: session "${target}" not found or has no path/tool`);
+                return;
+            }
+            if (executor) {
+                executor.execute([{ action: "create_agent", path: args.path, title: args.title, tool: args.tool }], [])
+                    .then(() => tui.log("+ action", `duplicate: spawned "${args.title}" (${args.tool}) at ${args.path}`))
+                    .catch((err) => tui.log("! action", `duplicate failed: ${err}`));
+            }
+            else {
+                tui.log("system", `[dry-run] duplicate: would spawn "${args.title}" (${args.tool}) at ${args.path}`);
+            }
+        });
+        // wire /color-all
+        input.onColorAll((colorName) => {
+            if (!colorName) {
+                const count = tui.setColorAll(null);
+                tui.log("system", `color-all: cleared accent color for ${count} sessions`);
+                persistPrefs();
+                return;
+            }
+            const err = validateColorName(colorName);
+            if (err) {
+                tui.log("system", err);
+                return;
+            }
+            const count = tui.setColorAll(colorName);
+            tui.log("system", `color-all: set ${colorName} for ${count} sessions`);
+            persistPrefs();
+        });
+        // wire /quiet-hours
+        input.onQuietHours((specs) => {
+            if (specs.length === 0) {
+                tui.setQuietHours([]);
+                tui.log("system", "quiet hours: cleared — alerts active at all hours");
+                persistPrefs();
+                return;
+            }
+            const ranges = [];
+            for (const spec of specs) {
+                const r = parseQuietHoursRange(spec);
+                if (!r) {
+                    tui.log("system", `quiet hours: invalid range "${spec}" — use HH-HH (e.g. 22-06)`);
+                    return;
+                }
+                ranges.push(r);
+            }
+            tui.setQuietHours(ranges);
+            tui.log("system", `quiet hours: ${specs.join(", ")} — watchdog+burn alerts suppressed`);
+            persistPrefs();
+        });
+        // wire /history-stats
+        input.onHistoryStats(() => {
+            const all = loadTuiHistory(100_000);
+            if (all.length === 0) {
+                tui.log("system", "history-stats: no history entries found");
+                return;
+            }
+            const stats = computeHistoryStats(all);
+            const oldest = stats.oldestTs ? new Date(stats.oldestTs).toLocaleDateString() : "?";
+            const newest = stats.newestTs ? new Date(stats.newestTs).toLocaleDateString() : "?";
+            tui.log("system", `history-stats: ${stats.totalEntries} entries over ${stats.spanDays} day(s) (${oldest} → ${newest})`);
+            const topTags = Object.entries(stats.tagCounts).slice(0, 5);
+            for (const [tag, count] of topTags) {
+                tui.log("system", `  ${tag}: ${count}`);
+            }
+        });
+        // wire /clear-history
+        input.onClearHistory(() => {
+            try {
+                writeFileSync(TUI_HISTORY_FILE, "", "utf-8");
+                tui.log("system", "history cleared — tui-history.jsonl truncated");
+            }
+            catch (err) {
+                tui.log("error", `clear-history failed: ${err}`);
+            }
+        });
         // wire /recall — search persisted history
         input.onRecall((keyword, maxResults) => {
             const matches = searchHistory(keyword, maxResults);
@@ -977,7 +1067,7 @@ async function main() {
                 return;
             }
             const now = Date.now();
-            const entries = buildSessionStats(sessions, tui.getSessionErrorCounts(), tui.getAllBurnRates(now), tui.getAllFirstSeen(), tui.getAllLastChangeAt(), tui.getAllHealthScores(now), tui.getAllSessionAliases(), now);
+            const entries = 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());
             tui.log("system", `/stats — ${entries.length} session${entries.length !== 1 ? "s" : ""}:`);
             for (const line of formatSessionStatsLines(entries)) {
                 tui.log("system", line);

package/dist/input.d.ts

@@ -47,6 +47,11 @@ export type FindHandler = (text: string) => void;
 export type ResetHealthHandler = (target: string) => void;
 export type TimelineHandler = (target: string, count: number) => void;
 export type ColorHandler = (target: string, colorName: string) => void;
+export type ClearHistoryHandler = () => void;
+export type DuplicateHandler = (target: string, newTitle: string) => void;
+export type ColorAllHandler = (colorName: string) => void;
+export type QuietHoursHandler = (specs: string[]) => void;
+export type HistoryStatsHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -116,6 +121,11 @@ export declare class InputReader {
     private resetHealthHandler;
     private timelineHandler;
     private colorHandler;
+    private clearHistoryHandler;
+    private duplicateHandler;
+    private colorAllHandler;
+    private quietHoursHandler;
+    private historyStatsHandler;
     private aliases;
     private mouseDataListener;
     onScroll(handler: (dir: ScrollDirection) => void): void;
@@ -168,6 +178,11 @@ export declare class InputReader {
     onResetHealth(handler: ResetHealthHandler): void;
     onTimeline(handler: TimelineHandler): void;
     onColor(handler: ColorHandler): void;
+    onClearHistory(handler: ClearHistoryHandler): void;
+    onDuplicate(handler: DuplicateHandler): void;
+    onColorAll(handler: ColorAllHandler): void;
+    onQuietHours(handler: QuietHoursHandler): void;
+    onHistoryStats(handler: HistoryStatsHandler): void;
     /** Set aliases from persisted prefs. */
     setAliases(aliases: Record<string, string>): void;
     /** Get current aliases as a plain object. */

package/dist/input.js

@@ -80,6 +80,11 @@ export class InputReader {
     resetHealthHandler = null;
     timelineHandler = null;
     colorHandler = null;
+    clearHistoryHandler = null;
+    duplicateHandler = null;
+    colorAllHandler = null;
+    quietHoursHandler = null;
+    historyStatsHandler = null;
     aliases = new Map(); // /shortcut → /full command
     mouseDataListener = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
@@ -282,6 +287,14 @@ export class InputReader {
     onColor(handler) {
         this.colorHandler = handler;
     }
+    // register a callback for /clear-history
+    onClearHistory(handler) {
+        this.clearHistoryHandler = handler;
+    }
+    onDuplicate(handler) { this.duplicateHandler = handler; }
+    onColorAll(handler) { this.colorAllHandler = handler; }
+    onQuietHours(handler) { this.quietHoursHandler = handler; }
+    onHistoryStats(handler) { this.historyStatsHandler = handler; }
     /** Set aliases from persisted prefs. */
     setAliases(aliases) {
         this.aliases.clear();
@@ -539,6 +552,11 @@ ${BOLD}navigation:${RESET}
   /reset-health N    clear error counts + context history for a session
   /timeline N [n]    show last n activity entries for session N (default 30)
   /color N [color]   set accent color for session (lime/amber/rose/teal/sky/slate; no color = clear)
+  /clear-history     truncate persisted activity history (tui-history.jsonl)
+  /duplicate N [t]   spawn a new session cloned from session N (same tool/path)
+  /color-all [c]     set accent color for all sessions (no color = clear all)
+  /quiet-hours [H-H] suppress watchdog+burn alerts during hours (e.g. 22-06; no arg = clear)
+  /history-stats     show aggregate statistics from persisted activity history
   /clip [N]          copy last N activity entries to clipboard (default 20)
   /diff N            show activity since bookmark N
   /mark              bookmark current activity position
@@ -1045,6 +1063,60 @@ ${BOLD}other:${RESET}
                 }
                 break;
             }
+            case "/duplicate": {
+                const dupArg = line.slice("/duplicate".length).trim();
+                if (!dupArg) {
+                    console.error(`${DIM}usage: /duplicate <N|name> [new-title]${RESET}`);
+                    break;
+                }
+                if (this.duplicateHandler) {
+                    const spaceIdx = dupArg.indexOf(" ");
+                    const target = spaceIdx > 0 ? dupArg.slice(0, spaceIdx) : dupArg;
+                    const newTitle = spaceIdx > 0 ? dupArg.slice(spaceIdx + 1).trim() : "";
+                    this.duplicateHandler(target, newTitle);
+                }
+                else {
+                    console.error(`${DIM}duplicate not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/color-all": {
+                const caArg = line.slice("/color-all".length).trim().toLowerCase() || "";
+                if (this.colorAllHandler) {
+                    this.colorAllHandler(caArg);
+                }
+                else {
+                    console.error(`${DIM}color-all not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/quiet-hours": {
+                const qhArg = line.slice("/quiet-hours".length).trim();
+                if (this.quietHoursHandler) {
+                    const specs = qhArg ? qhArg.split(/[\s,]+/).filter(Boolean) : [];
+                    this.quietHoursHandler(specs);
+                }
+                else {
+                    console.error(`${DIM}quiet-hours not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/history-stats":
+                if (this.historyStatsHandler) {
+                    this.historyStatsHandler();
+                }
+                else {
+                    console.error(`${DIM}history-stats not available (no TUI)${RESET}`);
+                }
+                break;
+            case "/clear-history":
+                if (this.clearHistoryHandler) {
+                    this.clearHistoryHandler();
+                }
+                else {
+                    console.error(`${DIM}clear-history not available (no TUI)${RESET}`);
+                }
+                break;
             case "/reset-health": {
                 const rhArg = line.slice("/reset-health".length).trim();
                 if (!rhArg) {

package/dist/tui-history.d.ts

@@ -25,6 +25,20 @@ 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;
+export interface HistoryStats {
+    totalEntries: number;
+    uniqueTags: string[];
+    tagCounts: Record<string, number>;
+    entriesPerDay: Record<string, number>;
+    oldestTs: number | null;
+    newestTs: number | null;
+    spanDays: number;
+}
+/**
+ * Compute aggregate statistics from a list of history entries.
+ * Pure function — no file I/O.
+ */
+export declare function computeHistoryStats(entries: readonly HistoryEntry[]): HistoryStats;
 /**
  * Search history entries by keyword (case-insensitive substring match on text and tag).
  * Returns up to `maxResults` most recent matching entries (newest last).

package/dist/tui-history.js

@@ -88,6 +88,39 @@ function isValidEntry(val) {
 }
 /** Default history file path (for wiring in index.ts) */
 export const TUI_HISTORY_FILE = HISTORY_FILE;
+/**
+ * Compute aggregate statistics from a list of history entries.
+ * Pure function — no file I/O.
+ */
+export function computeHistoryStats(entries) {
+    if (entries.length === 0) {
+        return { totalEntries: 0, uniqueTags: [], tagCounts: {}, entriesPerDay: {}, oldestTs: null, newestTs: null, spanDays: 0 };
+    }
+    const tagCounts = {};
+    const dayMap = {};
+    let oldest = Infinity, newest = -Infinity;
+    for (const e of entries) {
+        tagCounts[e.tag] = (tagCounts[e.tag] ?? 0) + 1;
+        const day = new Date(e.ts).toISOString().slice(0, 10);
+        dayMap[day] = (dayMap[day] ?? 0) + 1;
+        if (e.ts < oldest)
+            oldest = e.ts;
+        if (e.ts > newest)
+            newest = e.ts;
+    }
+    // sort tagCounts by count desc
+    const sortedTagCounts = Object.fromEntries(Object.entries(tagCounts).sort(([, a], [, b]) => b - a));
+    const spanDays = oldest === Infinity ? 0 : Math.max(1, Math.round((newest - oldest) / 86400000));
+    return {
+        totalEntries: entries.length,
+        uniqueTags: Object.keys(sortedTagCounts),
+        tagCounts: sortedTagCounts,
+        entriesPerDay: dayMap,
+        oldestTs: oldest === Infinity ? null : oldest,
+        newestTs: newest === -Infinity ? null : newest,
+        spanDays,
+    };
+}
 /**
  * Search history entries by keyword (case-insensitive substring match on text and tag).
  * Returns up to `maxResults` most recent matching entries (newest last).

package/dist/tui.d.ts

@@ -94,6 +94,16 @@ 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;
+/** Error trend: compare recent half of window vs older half. */
+export type ErrorTrend = "rising" | "stable" | "falling";
+/**
+ * Compute error trend from a list of recent error timestamps.
+ * Splits the window in half; if recent half has significantly more → rising, fewer → falling.
+ * "Significant" = difference of at least 1 error.
+ */
+export declare function computeErrorTrend(timestamps: readonly number[], now?: number, windowMs?: number): ErrorTrend;
+/** Format error trend as a directional arrow. */
+export declare function formatErrorTrend(trend: ErrorTrend): string;
 /** Default number of entries shown by /timeline. */
 export declare const TIMELINE_DEFAULT_COUNT = 30;
 /**
@@ -101,6 +111,26 @@ export declare const TIMELINE_DEFAULT_COUNT = 30;
  * Returns up to `count` entries.
  */
 export declare function filterSessionTimeline(buffer: readonly ActivityEntry[], sessionId: string, count?: number): ActivityEntry[];
+/**
+ * Build args for duplicating a session: given a source session, return
+ * { path, tool, title } for use in a create_agent action.
+ * Returns null if source session not found or path/tool missing.
+ */
+export declare function buildDuplicateArgs(sessions: readonly DaemonSessionState[], sessionIdOrIndex: string | number, newTitle?: string): {
+    path: string;
+    tool: string;
+    title: string;
+} | null;
+/**
+ * Check whether a given hour (0-23) falls within any quiet-hour range.
+ * Ranges are inclusive, e.g. "22-06" wraps midnight.
+ */
+export declare function isQuietHour(hour: number, ranges: ReadonlyArray<[number, number]>): boolean;
+/**
+ * Parse a quiet-hours string like "22-06" or "09-17" into a [start, end] tuple.
+ * Returns null if invalid.
+ */
+export declare function parseQuietHoursRange(spec: string): [number, number] | null;
 /** Supported accent color names for /color command. */
 export declare const SESSION_COLOR_NAMES: readonly ["lime", "amber", "rose", "teal", "sky", "slate", "indigo", "cyan"];
 export type SessionColorName = typeof SESSION_COLOR_NAMES[number];
@@ -131,15 +161,17 @@ export interface SessionStatEntry {
     status: string;
     health: number;
     errors: number;
+    errorTrend?: ErrorTrend;
     burnRatePerMin: number | null;
     contextPct: number | null;
+    costStr?: string;
     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[];
+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, errorTimestamps?: ReadonlyMap<string, readonly number[]>, sessionCosts?: ReadonlyMap<string, string>): SessionStatEntry[];
 /**
  * Format session stats entries as a multi-line activity-log-friendly string.
  * Each line is one session summary.
@@ -246,6 +278,7 @@ export interface TuiPrefs {
     sessionAliases?: Record<string, string>;
     sessionTags?: Record<string, string[]>;
     sessionColors?: Record<string, string>;
+    quietHours?: string[];
 }
 /** Load persisted TUI preferences. Returns empty object on any error. */
 export declare function loadTuiPrefs(): TuiPrefs;
@@ -301,6 +334,8 @@ export declare class TUI {
     private sessionTags;
     private tagFilter2;
     private sessionColors;
+    private sessionCosts;
+    private quietHoursRanges;
     private viewMode;
     private drilldownSessionId;
     private sessionOutputs;
@@ -418,6 +453,24 @@ export declare class TUI {
     getSessionColor(id: string): string | undefined;
     getAllSessionColors(): ReadonlyMap<string, string>;
     restoreSessionColors(colors: Record<string, string>): void;
+    /** Set the same accent color on all currently visible sessions (or clear all). */
+    setColorAll(colorName: string | null): number;
+    /** Set quiet-hours ranges (suppresses watchdog/burn-rate alerts). */
+    setQuietHours(ranges: Array<[number, number]>): void;
+    /** Get current quiet-hours ranges. */
+    getQuietHours(): ReadonlyArray<[number, number]>;
+    /** Check if current time is in a quiet-hours window. */
+    isCurrentlyQuiet(now?: Date): boolean;
+    /** Return the duplicate args for a session (for /duplicate wiring). */
+    getDuplicateArgs(sessionIdOrIndex: string | number, newTitle?: string): {
+        path: string;
+        tool: string;
+        title: string;
+    } | null;
+    /** Get the latest cost string for a session (or undefined). */
+    getSessionCost(id: string): string | undefined;
+    /** Return all session costs (for /stats). */
+    getAllSessionCosts(): ReadonlyMap<string, string>;
     getSessionTimeline(sessionIdOrIndex: string | number, count?: number): ActivityEntry[] | null;
     /** Set or clear the freeform tag filter (filters session panel). */
     setTagFilter2(tag: string | null): void;

package/dist/tui.js

@@ -312,6 +312,41 @@ export function formatIdleSince(ms, thresholdMs = 2 * 60_000) {
         return "";
     return `idle ${formatUptime(ms)}`;
 }
+/**
+ * Compute error trend from a list of recent error timestamps.
+ * Splits the window in half; if recent half has significantly more → rising, fewer → falling.
+ * "Significant" = difference of at least 1 error.
+ */
+export function computeErrorTrend(timestamps, now, windowMs = 10 * 60_000) {
+    if (timestamps.length === 0)
+        return "stable";
+    const nowMs = now ?? Date.now();
+    const cutoff = nowMs - windowMs;
+    const halfMs = windowMs / 2;
+    const midpoint = nowMs - halfMs;
+    let older = 0, newer = 0;
+    for (const ts of timestamps) {
+        if (ts < cutoff)
+            continue;
+        if (ts < midpoint)
+            older++;
+        else
+            newer++;
+    }
+    if (newer > older)
+        return "rising";
+    if (older > newer)
+        return "falling";
+    return "stable";
+}
+/** Format error trend as a directional arrow. */
+export function formatErrorTrend(trend) {
+    switch (trend) {
+        case "rising": return `${ROSE}↑${RESET}`;
+        case "falling": return `${LIME}↓${RESET}`;
+        default: return `${SLATE}→${RESET}`;
+    }
+}
 // ── Session timeline (pure, exported for testing) ────────────────────────────
 /** Default number of entries shown by /timeline. */
 export const TIMELINE_DEFAULT_COUNT = 30;
@@ -323,6 +358,62 @@ export function filterSessionTimeline(buffer, sessionId, count = TIMELINE_DEFAUL
     const matching = buffer.filter((e) => e.sessionId === sessionId);
     return matching.slice(-count);
 }
+// ── Duplicate session helpers (pure, exported for testing) ───────────────────
+/**
+ * Build args for duplicating a session: given a source session, return
+ * { path, tool, title } for use in a create_agent action.
+ * Returns null if source session not found or path/tool missing.
+ */
+export function buildDuplicateArgs(sessions, sessionIdOrIndex, newTitle) {
+    let s;
+    if (typeof sessionIdOrIndex === "number") {
+        s = sessions[sessionIdOrIndex - 1];
+    }
+    else {
+        const needle = sessionIdOrIndex.toLowerCase();
+        s = sessions.find((x) => x.id === sessionIdOrIndex || x.id.startsWith(needle) || x.title.toLowerCase() === needle);
+    }
+    if (!s || !s.path || !s.tool)
+        return null;
+    return {
+        path: s.path,
+        tool: s.tool,
+        title: newTitle?.trim() || `${s.title}-copy`,
+    };
+}
+// ── Quiet hours (pure, exported for testing) ──────────────────────────────────
+/**
+ * Check whether a given hour (0-23) falls within any quiet-hour range.
+ * Ranges are inclusive, e.g. "22-06" wraps midnight.
+ */
+export function isQuietHour(hour, ranges) {
+    for (const [start, end] of ranges) {
+        if (start <= end) {
+            if (hour >= start && hour <= end)
+                return true;
+        }
+        else {
+            // wraps midnight
+            if (hour >= start || hour <= end)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Parse a quiet-hours string like "22-06" or "09-17" into a [start, end] tuple.
+ * Returns null if invalid.
+ */
+export function parseQuietHoursRange(spec) {
+    const m = spec.trim().match(/^(\d{1,2})-(\d{1,2})$/);
+    if (!m)
+        return null;
+    const start = parseInt(m[1], 10);
+    const end = parseInt(m[2], 10);
+    if (start < 0 || start > 23 || end < 0 || end > 23)
+        return null;
+    return [start, end];
+}
 // ── Session accent colors (pure, exported for testing) ────────────────────────
 /** Supported accent color names for /color command. */
 export const SESSION_COLOR_NAMES = ["lime", "amber", "rose", "teal", "sky", "slate", "indigo", "cyan"];
@@ -393,21 +484,25 @@ export function formatSessionTagsBadge(tags) {
 /**
  * Build stats entries for all sessions — pure, testable, no side effects.
  */
-export function buildSessionStats(sessions, errorCounts, burnRates, firstSeen, lastChangeAt, healthScores, sessionAliases, now) {
+export function buildSessionStats(sessions, errorCounts, burnRates, firstSeen, lastChangeAt, healthScores, sessionAliases, now, errorTimestamps, sessionCosts) {
     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);
+        const errTs = errorTimestamps?.get(s.id);
+        const errTrend = errTs ? computeErrorTrend(errTs, nowMs) : undefined;
         return {
             title: s.title,
             displayName: sessionAliases.get(s.id),
             status: s.status,
             health: healthScores.get(s.id) ?? 100,
             errors: errorCounts.get(s.id) ?? 0,
+            errorTrend: errTrend,
             burnRatePerMin: burnRates.get(s.id) ?? null,
             contextPct: ctxPct,
+            costStr: sessionCosts?.get(s.id),
             uptimeMs: fs !== undefined ? nowMs - fs : null,
             idleSinceMs: lc !== undefined ? nowMs - lc : null,
         };
@@ -423,13 +518,15 @@ export function formatSessionStatsLines(entries) {
     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 trendStr = e.errorTrend ? ` ${e.errorTrend === "rising" ? "↑" : e.errorTrend === "falling" ? "↓" : "→"}` : "";
+        const errStr = e.errors > 0 ? ` ${e.errors}err${trendStr}` : "";
         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 costStr = e.costStr ? ` ${e.costStr}` : "";
         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}`;
+        return `  ${label} [${e.status}] ${healthStr}${errStr}${burnStr}${ctxStr}${costStr}${upStr}${idleStr}`;
     });
 }
 /** Format session stats entries as a JSON object for export. */
@@ -463,7 +560,8 @@ export const BUILTIN_COMMANDS = new Set([
     "/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", "/stats", "/recall", "/pin-all-errors", "/export-stats",
-    "/mute-errors", "/prev-goal", "/tag", "/tags", "/tag-filter", "/find", "/reset-health", "/timeline", "/color",
+    "/mute-errors", "/prev-goal", "/tag", "/tags", "/tag-filter", "/find", "/reset-health", "/timeline", "/color", "/clear-history",
+    "/duplicate", "/color-all", "/quiet-hours", "/history-stats",
 ]);
 /** Resolve a slash command through the alias map. Returns the expanded command or the original. */
 export function resolveAlias(line, aliases) {
@@ -733,6 +831,8 @@ export class TUI {
     sessionTags = new Map(); // session ID → freeform tag set
     tagFilter2 = null; // active freeform tag filter on session panel
     sessionColors = new Map(); // session ID → accent color name
+    sessionCosts = new Map(); // session ID → latest cost string ("$N.NN")
+    quietHoursRanges = []; // quiet-hour start/end pairs
     // drill-down mode: show a single session's full output
     viewMode = "overview";
     drilldownSessionId = null;
@@ -1168,7 +1268,51 @@ export class TUI {
         for (const [id, c] of Object.entries(colors))
             this.sessionColors.set(id, c);
     }
+    /** Set the same accent color on all currently visible sessions (or clear all). */
+    setColorAll(colorName) {
+        let count = 0;
+        for (const s of this.sessions) {
+            if (!colorName) {
+                this.sessionColors.delete(s.id);
+            }
+            else {
+                this.sessionColors.set(s.id, colorName);
+            }
+            count++;
+        }
+        if (count > 0 && this.active)
+            this.paintSessions();
+        return count;
+    }
+    // ── Quiet hours ──────────────────────────────────────────────────────────
+    /** Set quiet-hours ranges (suppresses watchdog/burn-rate alerts). */
+    setQuietHours(ranges) {
+        this.quietHoursRanges = ranges;
+    }
+    /** Get current quiet-hours ranges. */
+    getQuietHours() {
+        return this.quietHoursRanges;
+    }
+    /** Check if current time is in a quiet-hours window. */
+    isCurrentlyQuiet(now) {
+        if (this.quietHoursRanges.length === 0)
+            return false;
+        const hour = (now ?? new Date()).getHours();
+        return isQuietHour(hour, this.quietHoursRanges);
+    }
+    /** Return the duplicate args for a session (for /duplicate wiring). */
+    getDuplicateArgs(sessionIdOrIndex, newTitle) {
+        return buildDuplicateArgs(this.sessions, sessionIdOrIndex, newTitle);
+    }
     // ── Session timeline ─────────────────────────────────────────────────────
+    /** Get the latest cost string for a session (or undefined). */
+    getSessionCost(id) {
+        return this.sessionCosts.get(id);
+    }
+    /** Return all session costs (for /stats). */
+    getAllSessionCosts() {
+        return this.sessionCosts;
+    }
     getSessionTimeline(sessionIdOrIndex, count = TIMELINE_DEFAULT_COUNT) {
         let sessionId;
         if (typeof sessionIdOrIndex === "number") {
@@ -1475,6 +1619,7 @@ export class TUI {
             // track activity changes for sort-by-activity + first-seen for uptime
             const now = Date.now();
             const BURN_ALERT_COOLDOWN_MS = 5 * 60 * 1000; // max one alert per session per 5 minutes
+            const quietNow = this.isCurrentlyQuiet(new Date(now));
             for (const s of opts.sessions) {
                 if (!this.sessionFirstSeen.has(s.id))
                     this.sessionFirstSeen.set(s.id, now);
@@ -1484,6 +1629,9 @@ export class TUI {
                 }
                 if (s.lastActivity !== undefined)
                     this.prevLastActivity.set(s.id, s.lastActivity);
+                // track cost string
+                if (s.costStr)
+                    this.sessionCosts.set(s.id, s.costStr);
                 // track context token history for burn-rate alerts
                 const tokens = parseContextTokenNumber(s.contextTokens);
                 if (tokens !== null) {
@@ -1494,7 +1642,7 @@ export class TUI {
                     this.sessionContextHistory.set(s.id, hist);
                     // check burn rate and emit alert if above threshold (with cooldown)
                     const burnRate = computeContextBurnRate(hist, now);
-                    if (burnRate !== null && burnRate > CONTEXT_BURN_THRESHOLD) {
+                    if (burnRate !== null && burnRate > CONTEXT_BURN_THRESHOLD && !quietNow) {
                         const lastAlert = this.burnRateAlerted.get(s.id) ?? 0;
                         if (now - lastAlert >= BURN_ALERT_COOLDOWN_MS) {
                             this.burnRateAlerted.set(s.id, now);
@@ -1504,7 +1652,7 @@ export class TUI {
                 }
                 // check context ceiling and emit alert if above threshold (with cooldown)
                 const ceiling = parseContextCeiling(s.contextTokens);
-                if (ceiling !== null && ceiling.current / ceiling.max >= CONTEXT_CEILING_THRESHOLD) {
+                if (ceiling !== null && ceiling.current / ceiling.max >= CONTEXT_CEILING_THRESHOLD && !quietNow) {
                     const lastCeiling = this.ceilingAlerted.get(s.id) ?? 0;
                     if (now - lastCeiling >= BURN_ALERT_COOLDOWN_MS) {
                         this.ceilingAlerted.set(s.id, now);
@@ -1512,8 +1660,8 @@ export class TUI {
                     }
                 }
             }
-            // watchdog: alert if session has been idle longer than threshold
-            if (this.watchdogThresholdMs !== null) {
+            // watchdog: alert if session has been idle longer than threshold (skip during quiet hours)
+            if (this.watchdogThresholdMs !== null && !quietNow) {
                 for (const s of opts.sessions) {
                     const lastChange = this.lastChangeAt.get(s.id);
                     if (lastChange === undefined)

package/dist/types.d.ts

@@ -136,6 +136,8 @@ export interface DaemonSessionState {
     contextTokens?: string;
     todoSummary?: string;
     userActive?: boolean;
+    costStr?: string;
+    path?: string;
 }
 export interface DaemonState {
     tickStartedAt: number;

package/package.json

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