aoaoe 0.66.0 → 0.68.0

package/dist/config-watcher.d.ts

@@ -0,0 +1,44 @@
+import type { AoaoeConfig } from "./types.js";
+/** Describes a single config field change */
+export interface ConfigChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    applied: boolean;
+}
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export declare function mergeHotReload(current: AoaoeConfig, fresh: AoaoeConfig): {
+    config: AoaoeConfig;
+    changes: ConfigChange[];
+};
+/**
+ * Format a config change for display in the TUI.
+ */
+export declare function formatConfigChange(change: ConfigChange): string;
+export type ConfigChangeCallback = (changes: ConfigChange[], newConfig: AoaoeConfig) => void;
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export declare class ConfigWatcher {
+    private watcher;
+    private debounceTimer;
+    private configPath;
+    private callback;
+    private currentConfig;
+    private debounceMs;
+    constructor(config: AoaoeConfig, debounceMs?: number);
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback: ConfigChangeCallback): string | null;
+    /** Stop watching */
+    stop(): void;
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig(): AoaoeConfig;
+    private scheduleReload;
+    private doReload;
+}
+//# sourceMappingURL=config-watcher.d.ts.map

package/dist/config-watcher.js

@@ -0,0 +1,159 @@
+// config-watcher.ts — watch config file for changes and hot-reload safe fields.
+// pure mergeHotReload function + ConfigWatcher class using fs.watch.
+import { watch } from "node:fs";
+import { loadConfig, findConfigFile, validateConfig } from "./config.js";
+/**
+ * Fields that are safe to hot-reload without restarting the daemon.
+ * Fields NOT in this list require a daemon restart to take effect.
+ *
+ * Unsafe (require restart): reasoner, opencode.port, healthPort, dryRun, observe, confirm
+ */
+const HOT_RELOAD_FIELDS = new Set([
+    "pollIntervalMs",
+    "sessionDirs",
+    "protectedSessions",
+    "contextFiles",
+    "verbose",
+    "captureLinesCount",
+    "tuiHistoryRetentionDays",
+]);
+/** Nested objects where all sub-fields are safe to hot-reload */
+const HOT_RELOAD_OBJECTS = new Set([
+    "policies",
+    "notifications",
+]);
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export function mergeHotReload(current, fresh) {
+    const changes = [];
+    const merged = { ...current };
+    // check top-level scalar/array fields
+    for (const field of HOT_RELOAD_FIELDS) {
+        const key = field;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // check nested objects (policies, notifications)
+    for (const objField of HOT_RELOAD_OBJECTS) {
+        const key = objField;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: objField, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // detect non-reloadable changes (warn user)
+    const unsafeFields = [
+        "reasoner", "dryRun", "observe", "confirm", "healthPort",
+    ];
+    for (const key of unsafeFields) {
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: key, oldValue: current[key], newValue: fresh[key], applied: false });
+        }
+    }
+    // check nested non-reloadable (opencode.port)
+    if (current.opencode?.port !== fresh.opencode?.port) {
+        changes.push({ field: "opencode.port", oldValue: current.opencode?.port, newValue: fresh.opencode?.port, applied: false });
+    }
+    return { config: merged, changes };
+}
+/**
+ * Format a config change for display in the TUI.
+ */
+export function formatConfigChange(change) {
+    const status = change.applied ? "applied" : "requires restart";
+    const newVal = typeof change.newValue === "object"
+        ? JSON.stringify(change.newValue)
+        : String(change.newValue);
+    const truncated = newVal.length > 60 ? newVal.slice(0, 57) + "..." : newVal;
+    return `${change.field}: ${truncated} (${status})`;
+}
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export class ConfigWatcher {
+    watcher = null;
+    debounceTimer = null;
+    configPath = null;
+    callback = null;
+    currentConfig;
+    debounceMs;
+    constructor(config, debounceMs = 500) {
+        this.currentConfig = config;
+        this.debounceMs = debounceMs;
+    }
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback) {
+        this.callback = callback;
+        this.configPath = findConfigFile();
+        if (!this.configPath)
+            return null;
+        try {
+            this.watcher = watch(this.configPath, { persistent: false }, () => {
+                this.scheduleReload();
+            });
+            this.watcher.on("error", () => {
+                // config file may be renamed during save — try to re-watch
+                this.stop();
+            });
+        }
+        catch {
+            // watch failed — degrade gracefully
+            return null;
+        }
+        return this.configPath;
+    }
+    /** Stop watching */
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch { }
+            this.watcher = null;
+        }
+    }
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig() {
+        return this.currentConfig;
+    }
+    scheduleReload() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.doReload();
+        }, this.debounceMs);
+    }
+    doReload() {
+        try {
+            const fresh = loadConfig();
+            validateConfig(fresh);
+            const { config, changes } = mergeHotReload(this.currentConfig, fresh);
+            if (changes.length > 0) {
+                this.currentConfig = config;
+                this.callback?.(changes, config);
+            }
+        }
+        catch (err) {
+            // invalid config — ignore silently (keep running with current config)
+            console.error(`[config-watcher] reload failed: ${err}`);
+        }
+    }
+}
+//# sourceMappingURL=config-watcher.js.map

package/dist/config.js

@@ -593,6 +593,8 @@ interactive commands (while daemon is running):
   /help          show available commands
   /explain       ask the AI to explain what's happening in plain English
   /insist <msg>  interrupt + deliver message immediately (skip queue)
+  /view [N|name] drill into a session's live output (default: 1)
+  /back          return to overview from drill-down
   /status        request daemon status
   /dashboard     request full dashboard output
   /pause         pause the daemon
@@ -600,6 +602,8 @@ interactive commands (while daemon is running):
   /interrupt     interrupt the current reasoner call
   /verbose       toggle verbose logging
   /clear         clear the screen
+  PgUp / PgDn    scroll through activity history
+  Home / End     jump to oldest / return to live
   ESC ESC        interrupt the current reasoner (shortcut)
   !message       insist shortcut — same as /insist message
   (anything)     send a message to the AI — queued for next cycle`);

package/dist/executor.d.ts

@@ -10,6 +10,8 @@ export declare class Executor {
     private taskManager?;
     constructor(config: AoaoeConfig);
     setTaskManager(tm: TaskManager): void;
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig: AoaoeConfig): void;
     execute(actions: Action[], snapshots: SessionSnapshot[]): Promise<ActionLogEntry[]>;
     private executeOne;
     private sendInput;

package/dist/executor.js

@@ -32,6 +32,10 @@ export class Executor {
     setTaskManager(tm) {
         this.taskManager = tm;
     }
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig) {
+        this.config = newConfig;
+    }
     async execute(actions, snapshots) {
         const results = [];
         for (const action of actions) {

package/dist/index.js

@@ -20,6 +20,7 @@ import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
 import { loadTuiHistory } 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";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
@@ -137,7 +138,7 @@ async function main() {
     }
     const configResult = loadConfig(overrides);
     const configPath = configResult._configPath;
-    const config = configResult; // strip _configPath from type for downstream
+    let config = configResult; // strip _configPath from type for downstream (let: hot-reloaded)
     // acquire daemon lock — prevent two daemons from running simultaneously
     const lock = acquireLock();
     if (!lock.acquired) {
@@ -257,6 +258,24 @@ async function main() {
         input.onQueueChange((count) => {
             tui.updateState({ pendingCount: count });
         });
+        // wire /view and /back commands to TUI drill-down
+        input.onView((target) => {
+            if (target === null) {
+                tui.exitDrilldown();
+                tui.log("system", "returned to overview");
+            }
+            else {
+                // try number first, then name/id
+                const num = parseInt(target, 10);
+                const ok = !isNaN(num) ? tui.enterDrilldown(num) : tui.enterDrilldown(target);
+                if (ok) {
+                    tui.log("system", `viewing session: ${target}`);
+                }
+                else {
+                    tui.log("system", `session not found: ${target}`);
+                }
+            }
+        });
     }
     // start TUI (alternate screen buffer) after input is ready
     if (tui) {
@@ -355,6 +374,7 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        configWatcher.stop();
         if (healthServer)
             healthServer.close();
         // notify: daemon stopped (fire-and-forget, don't block shutdown)
@@ -382,6 +402,36 @@ async function main() {
     else {
         log("entering main loop (Ctrl+C to stop)\n");
     }
+    // ── config hot-reload watcher ──────────────────────────────────────────────
+    const configWatcher = new ConfigWatcher(config);
+    const watchedPath = configWatcher.start((changes, newConfig) => {
+        config = newConfig;
+        if (executor)
+            executor.updateConfig(newConfig);
+        const applied = changes.filter((c) => c.applied);
+        const needsRestart = changes.filter((c) => !c.applied);
+        for (const c of applied) {
+            const msg = `config: ${formatConfigChange(c)}`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+        for (const c of needsRestart) {
+            const msg = `config: ${c.field} changed but requires restart`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+    });
+    if (watchedPath) {
+        const msg = `watching config: ${watchedPath}`;
+        if (tui)
+            tui.log("system", msg);
+        else
+            log(msg);
+    }
     // notify: daemon started
     sendNotification(config, { event: "daemon_started", timestamp: Date.now(), detail: `reasoner: ${config.reasoner}` });
     // clear any stale interrupt from a previous run
@@ -703,9 +753,16 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
     const sessionStates = buildSessionStates(observation);
     const taskStates = taskManager ? taskManager.tasks : undefined;
     writeState("polling", { pollCount, sessionCount, changeCount, sessions: sessionStates, tasks: taskStates });
-    // update TUI session panel
-    if (tui)
+    // update TUI session panel + drill-down outputs
+    if (tui) {
         tui.updateState({ phase: "polling", pollCount, sessions: sessionStates });
+        // pass full session outputs for drill-down view
+        const outputs = new Map();
+        for (const snap of observation.sessions) {
+            outputs.set(snap.session.id, snap.output);
+        }
+        tui.setSessionOutputs(outputs);
+    }
     const noStats = { interrupted: false, decisionsThisTick: 0, actionsOk: 0, actionsFail: 0 };
     // skip cases
     if (skippedReason === "no sessions") {

package/dist/input.d.ts

@@ -1,5 +1,6 @@
 export type ScrollDirection = "up" | "down" | "top" | "bottom";
 export declare const INSIST_PREFIX = "__INSIST__";
+export type ViewHandler = (target: string | null) => void;
 export declare class InputReader {
     private rl;
     private queue;
@@ -7,8 +8,10 @@ export declare class InputReader {
     private lastEscTime;
     private scrollHandler;
     private queueChangeHandler;
+    private viewHandler;
     onScroll(handler: (dir: ScrollDirection) => void): void;
     onQueueChange(handler: (count: number) => void): void;
+    onView(handler: ViewHandler): void;
     private notifyQueueChange;
     start(): void;
     drain(): string[];

package/dist/input.js

@@ -14,6 +14,7 @@ export class InputReader {
     lastEscTime = 0;
     scrollHandler = null;
     queueChangeHandler = null;
+    viewHandler = null;
     // register a callback for scroll key events (PgUp/PgDn/Home/End)
     onScroll(handler) {
         this.scrollHandler = handler;
@@ -22,6 +23,10 @@ export class InputReader {
     onQueueChange(handler) {
         this.queueChangeHandler = handler;
     }
+    // register a callback for view commands (/view, /back)
+    onView(handler) {
+        this.viewHandler = handler;
+    }
     notifyQueueChange() {
         this.queueChangeHandler?.(this.queue.length);
     }
@@ -158,6 +163,10 @@ ${BOLD}controls:${RESET}
   /resume            resume the supervisor
   /interrupt         interrupt the AI mid-thought
   ESC ESC            same as /interrupt (shortcut)
+
+${BOLD}navigation:${RESET}
+  /view [N|name]     drill into a session's live output (default: 1)
+  /back              return to overview from drill-down
   PgUp / PgDn        scroll through activity history
   Home / End         jump to oldest / return to live
 
@@ -215,6 +224,24 @@ ${BOLD}other:${RESET}
                 this.queue.push(`__CMD_TASK__${taskArgs}`);
                 break;
             }
+            case "/view": {
+                const viewArg = line.slice("/view".length).trim();
+                if (this.viewHandler) {
+                    this.viewHandler(viewArg || "1"); // default to session 1
+                }
+                else {
+                    console.error(`${DIM}drill-down not available (no TUI)${RESET}`);
+                }
+                break;
+            }
+            case "/back":
+                if (this.viewHandler) {
+                    this.viewHandler(null); // null = back to overview
+                }
+                else {
+                    console.error(`${DIM}already in overview${RESET}`);
+                }
+                break;
             case "/clear":
                 process.stderr.write("\x1b[2J\x1b[H");
                 break;

package/dist/tui.d.ts

@@ -23,6 +23,9 @@ export declare class TUI {
     private scrollOffset;
     private newWhileScrolled;
     private pendingCount;
+    private viewMode;
+    private drilldownSessionId;
+    private sessionOutputs;
     private phase;
     private pollCount;
     private sessions;
@@ -49,6 +52,16 @@ export declare class TUI {
     scrollToTop(): void;
     scrollToBottom(): void;
     isScrolledBack(): boolean;
+    /** Store full session outputs (called each tick from main loop) */
+    setSessionOutputs(outputs: Map<string, string>): void;
+    /** Enter drill-down view for a session. Returns false if session not found. */
+    enterDrilldown(sessionIdOrIndex: string | number): boolean;
+    /** Exit drill-down, return to overview */
+    exitDrilldown(): void;
+    /** Get current view mode */
+    getViewMode(): "overview" | "drilldown";
+    /** Get drill-down session ID (or null) */
+    getDrilldownSessionId(): string | null;
     private updateDimensions;
     private computeLayout;
     private onResize;
@@ -58,6 +71,8 @@ export declare class TUI {
     private paintSeparator;
     private writeActivityLine;
     private repaintActivityRegion;
+    private paintDrilldownSeparator;
+    private repaintDrilldownContent;
     private paintInputLine;
 }
 declare function formatSessionCard(s: DaemonSessionState, maxWidth: number): string;
@@ -72,11 +87,12 @@ declare function truncatePlain(str: string, max: number): string;
  * Kept for backward compatibility — used by non-TUI output paths.
  */
 export declare function formatSessionSentence(s: DaemonSessionState, maxCols: number): string;
+declare function formatDrilldownHeader(sessionId: string, sessions: DaemonSessionState[], phase: DaemonPhase, paused: boolean, spinnerFrame: number, _cols: number): string;
 declare function formatPrompt(phase: DaemonPhase, paused: boolean, pendingCount: number): string;
 declare function computeScrollSlice(bufferLen: number, visibleLines: number, scrollOffset: number): {
     start: number;
     end: number;
 };
 declare function formatScrollIndicator(offset: number, totalEntries: number, visibleLines: number, newCount: number): string;
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt, formatDrilldownHeader };
 //# sourceMappingURL=tui.d.ts.map

package/dist/tui.js

@@ -58,6 +58,10 @@ export class TUI {
     scrollOffset = 0; // 0 = live (bottom), >0 = scrolled back N entries
     newWhileScrolled = 0; // entries added while user is scrolled back
     pendingCount = 0; // queued user messages awaiting next tick
+    // drill-down mode: show a single session's full output
+    viewMode = "overview";
+    drilldownSessionId = null;
+    sessionOutputs = new Map(); // full output lines per session
     // current state for repaints
     phase = "sleeping";
     pollCount = 0;
@@ -210,6 +214,61 @@ export class TUI {
     isScrolledBack() {
         return this.scrollOffset > 0;
     }
+    // ── Drill-down mode ────────────────────────────────────────────────────
+    /** Store full session outputs (called each tick from main loop) */
+    setSessionOutputs(outputs) {
+        for (const [id, text] of outputs) {
+            this.sessionOutputs.set(id, text.split("\n"));
+        }
+        // repaint drill-down view if we're watching this session
+        if (this.active && this.viewMode === "drilldown" && this.drilldownSessionId) {
+            this.repaintDrilldownContent();
+        }
+    }
+    /** Enter drill-down view for a session. Returns false if session not found. */
+    enterDrilldown(sessionIdOrIndex) {
+        let sessionId;
+        if (typeof sessionIdOrIndex === "number") {
+            const idx = sessionIdOrIndex - 1; // 1-indexed for user
+            if (idx >= 0 && idx < this.sessions.length) {
+                sessionId = this.sessions[idx].id;
+            }
+        }
+        else {
+            // match by id prefix or title (case-insensitive)
+            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.viewMode = "drilldown";
+        this.drilldownSessionId = sessionId;
+        if (this.active) {
+            this.computeLayout(this.sessions.length);
+            this.paintAll();
+        }
+        return true;
+    }
+    /** Exit drill-down, return to overview */
+    exitDrilldown() {
+        if (this.viewMode === "overview")
+            return;
+        this.viewMode = "overview";
+        this.drilldownSessionId = null;
+        if (this.active) {
+            this.computeLayout(this.sessions.length);
+            this.paintAll();
+        }
+    }
+    /** Get current view mode */
+    getViewMode() {
+        return this.viewMode;
+    }
+    /** Get drill-down session ID (or null) */
+    getDrilldownSessionId() {
+        return this.drilldownSessionId;
+    }
     // ── Layout computation ──────────────────────────────────────────────────
     updateDimensions() {
         this.cols = process.stderr.columns || 80;
@@ -217,17 +276,23 @@ export class TUI {
     }
     computeLayout(sessionCount) {
         this.updateDimensions();
-        // header: 1 row
-        // sessions: top border (1) + N session rows + bottom border (1) = N+2
-        // if no sessions, just show an empty box (2 rows: top + bottom borders)
-        const sessBodyRows = Math.max(sessionCount, 1); // at least 1 row for "no agents"
-        this.sessionRows = sessBodyRows + 2; // + top/bottom borders
-        this.separatorRow = this.headerHeight + this.sessionRows + 1;
-        // input line is the last row
-        this.inputRow = this.rows;
-        // scroll region: from separator+1 to rows-1 (leave room for input)
-        this.scrollTop = this.separatorRow + 1;
-        this.scrollBottom = this.rows - 1;
+        if (this.viewMode === "drilldown") {
+            // drilldown: header (1) + separator (1) + content + input (1)
+            this.sessionRows = 0;
+            this.separatorRow = this.headerHeight + 1;
+            this.inputRow = this.rows;
+            this.scrollTop = this.separatorRow + 1;
+            this.scrollBottom = this.rows - 1;
+        }
+        else {
+            // overview: header (1) + sessions box + separator + activity + input
+            const sessBodyRows = Math.max(sessionCount, 1);
+            this.sessionRows = sessBodyRows + 2; // + top/bottom borders
+            this.separatorRow = this.headerHeight + this.sessionRows + 1;
+            this.inputRow = this.rows;
+            this.scrollTop = this.separatorRow + 1;
+            this.scrollBottom = this.rows - 1;
+        }
         if (this.active) {
             process.stderr.write(setScrollRegion(this.scrollTop, this.scrollBottom));
         }
@@ -243,25 +308,37 @@ export class TUI {
         process.stderr.write(CLEAR_SCREEN);
         process.stderr.write(setScrollRegion(this.scrollTop, this.scrollBottom));
         this.paintHeader();
-        this.paintSessions();
-        this.paintSeparator();
-        this.repaintActivityRegion();
+        if (this.viewMode === "drilldown") {
+            this.paintDrilldownSeparator();
+            this.repaintDrilldownContent();
+        }
+        else {
+            this.paintSessions();
+            this.paintSeparator();
+            this.repaintActivityRegion();
+        }
         this.paintInputLine();
     }
     paintHeader() {
-        const phaseText = phaseDisplay(this.phase, this.paused, this.spinnerFrame);
-        const sessCount = `${this.sessions.length} agent${this.sessions.length !== 1 ? "s" : ""}`;
-        const activeCount = this.sessions.filter((s) => s.userActive).length;
-        const activeTag = activeCount > 0 ? `  ${SLATE}│${RESET}  ${AMBER}${activeCount} user${RESET}` : "";
-        // countdown to next tick (only in sleeping phase)
-        let countdownTag = "";
-        if (this.phase === "sleeping" && this.nextTickAt > 0) {
-            const remaining = Math.max(0, Math.ceil((this.nextTickAt - Date.now()) / 1000));
-            countdownTag = `  ${SLATE}│${RESET}  ${SLATE}${remaining}s${RESET}`;
+        let line;
+        if (this.viewMode === "drilldown" && this.drilldownSessionId) {
+            line = formatDrilldownHeader(this.drilldownSessionId, this.sessions, this.phase, this.paused, this.spinnerFrame, this.cols);
+        }
+        else {
+            const phaseText = phaseDisplay(this.phase, this.paused, this.spinnerFrame);
+            const sessCount = `${this.sessions.length} agent${this.sessions.length !== 1 ? "s" : ""}`;
+            const activeCount = this.sessions.filter((s) => s.userActive).length;
+            const activeTag = activeCount > 0 ? `  ${SLATE}│${RESET}  ${AMBER}${activeCount} user${RESET}` : "";
+            // countdown to next tick (only in sleeping phase)
+            let countdownTag = "";
+            if (this.phase === "sleeping" && this.nextTickAt > 0) {
+                const remaining = Math.max(0, Math.ceil((this.nextTickAt - Date.now()) / 1000));
+                countdownTag = `  ${SLATE}│${RESET}  ${SLATE}${remaining}s${RESET}`;
+            }
+            // 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}`;
         }
-        // reasoner badge
-        const reasonerTag = this.reasonerName ? `  ${SLATE}│${RESET}  ${TEAL}${this.reasonerName}${RESET}` : "";
-        const line = ` ${INDIGO}${BOLD}aoaoe${RESET} ${SLATE}${this.version}${RESET}  ${SLATE}│${RESET}  #${this.pollCount}  ${SLATE}│${RESET}  ${sessCount}  ${SLATE}│${RESET}  ${phaseText}${activeTag}${countdownTag}${reasonerTag}`;
         process.stderr.write(SAVE_CURSOR +
             moveTo(1, 1) + CLEAR_LINE + BG_DARK + WHITE + truncateAnsi(line, this.cols) + padToWidth(line, this.cols) + RESET +
             RESTORE_CURSOR);
@@ -339,6 +416,38 @@ export class TUI {
             }
         }
     }
+    // ── Drill-down rendering ──────────────────────────────────────────────
+    paintDrilldownSeparator() {
+        const session = this.sessions.find((s) => s.id === this.drilldownSessionId);
+        const title = session ? session.title : this.drilldownSessionId ?? "?";
+        const prefix = `${BOX.h}${BOX.h} ${title} `;
+        const hints = " /back: overview  /view N: switch session ";
+        const totalLen = prefix.length + hints.length;
+        const fill = Math.max(0, this.cols - totalLen);
+        const left = Math.floor(fill / 2);
+        const right = Math.ceil(fill / 2);
+        const line = `${SLATE}${prefix}${BOX.h.repeat(left)}${DIM}${hints}${RESET}${SLATE}${BOX.h.repeat(right)}${RESET}`;
+        process.stderr.write(SAVE_CURSOR + moveTo(this.separatorRow, 1) + CLEAR_LINE + truncateAnsi(line, this.cols) + RESTORE_CURSOR);
+    }
+    repaintDrilldownContent() {
+        if (!this.drilldownSessionId)
+            return;
+        const outputLines = this.sessionOutputs.get(this.drilldownSessionId) ?? [];
+        const visibleLines = this.scrollBottom - this.scrollTop + 1;
+        // show the last N lines (tail view, like following output)
+        const startIdx = Math.max(0, outputLines.length - visibleLines);
+        const visible = outputLines.slice(startIdx);
+        for (let i = 0; i < visibleLines; i++) {
+            const row = this.scrollTop + i;
+            if (i < visible.length) {
+                const line = `  ${visible[i]}`;
+                process.stderr.write(moveTo(row, 1) + CLEAR_LINE + truncateAnsi(line, this.cols));
+            }
+            else {
+                process.stderr.write(moveTo(row, 1) + CLEAR_LINE);
+            }
+        }
+    }
     paintInputLine() {
         const prompt = formatPrompt(this.phase, this.paused, this.pendingCount);
         process.stderr.write(SAVE_CURSOR +
@@ -488,6 +597,25 @@ export function formatSessionSentence(s, maxCols) {
     }
     return truncateAnsi(`${dot} ${BOLD}${name}${RESET} ${tool} ${SLATE}—${RESET} ${statusDesc}`, maxCols);
 }
+// ── Drill-down helpers (pure, exported for testing) ─────────────────────────
+// format the header line for drill-down view
+function formatDrilldownHeader(sessionId, sessions, phase, paused, spinnerFrame, _cols) {
+    const session = sessions.find((s) => s.id === sessionId);
+    const phaseText = phaseDisplay(phase, paused, spinnerFrame);
+    if (!session) {
+        return ` ${INDIGO}${BOLD}aoaoe${RESET}  ${SLATE}│${RESET}  ${DIM}session not found${RESET}  ${SLATE}│${RESET}  ${phaseText}`;
+    }
+    const dot = STATUS_DOT[session.status] ?? `${AMBER}${DOT.filled}${RESET}`;
+    const name = `${BOLD}${session.title}${RESET}`;
+    const toolBadge = `${SLATE}${session.tool}${RESET}`;
+    const statusText = session.status === "working" || session.status === "running"
+        ? `${LIME}${session.status}${RESET}`
+        : session.status === "error"
+            ? `${ROSE}error${RESET}`
+            : `${SLATE}${session.status}${RESET}`;
+    const taskTag = session.currentTask ? `  ${SLATE}│${RESET}  ${DIM}${truncatePlain(session.currentTask, 40)}${RESET}` : "";
+    return ` ${dot} ${name} ${toolBadge}  ${SLATE}│${RESET}  ${statusText}${taskTag}  ${SLATE}│${RESET}  ${phaseText}`;
+}
 // ── Prompt helpers (pure, exported for testing) ─────────────────────────────
 // format the input prompt based on phase, pause state, and pending queue count
 function formatPrompt(phase, paused, pendingCount) {
@@ -512,5 +640,5 @@ function formatScrollIndicator(offset, totalEntries, visibleLines, newCount) {
     return ` ↑ ${offset} older  │  ${position}/${totalEntries}  │  PgUp/PgDn  End=live${newTag} `;
 }
 // ── Exported pure helpers (for testing) ─────────────────────────────────────
-export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay, computeScrollSlice, formatScrollIndicator, formatPrompt, formatDrilldownHeader };
 //# sourceMappingURL=tui.js.map

package/package.json

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