aoaoe 0.45.0 → 0.47.0

package/README.md

@@ -410,8 +410,8 @@ The reasoner returns structured JSON decisions:
 { "action": "stop_session", "session": "<id>" }
 { "action": "create_agent", "path": "<dir>", "title": "<name>", "tool": "<agent>" }
 { "action": "remove_agent", "session": "<id>" }
-{ "action": "report_progress", "repo": "<path>", "summary": "<milestone>" }
-{ "action": "complete_task", "repo": "<path>", "summary": "<final status>" }
+{ "action": "report_progress", "session": "<id>", "summary": "<milestone>" }
+{ "action": "complete_task", "session": "<id>", "summary": "<final status>" }
 { "action": "wait" }
 ```
 

package/dist/chat.js

@@ -377,6 +377,8 @@ export function getCountdownFromState(state, daemonRunning, now = Date.now()) {
 function checkDaemon() {
     if (isDaemonRunning()) {
         const state = readState();
+        if (!state)
+            return;
         const eta = getCountdown();
         console.log(`${GREEN}daemon connected${RESET} ${DIM}(${state.sessionCount} sessions, poll #${state.pollCount})${RESET}`);
         if (eta !== null)

package/dist/colors.d.ts

@@ -1,11 +1,44 @@
 export declare const RESET = "\u001B[0m";
 export declare const BOLD = "\u001B[1m";
 export declare const DIM = "\u001B[2m";
+export declare const ITALIC = "\u001B[3m";
 export declare const RED = "\u001B[31m";
 export declare const GREEN = "\u001B[32m";
 export declare const YELLOW = "\u001B[33m";
 export declare const CYAN = "\u001B[36m";
-export declare const MAGENTA = "\u001B[35m";
 export declare const WHITE = "\u001B[37m";
+export declare const INDIGO = "\u001B[38;5;105m";
+export declare const TEAL = "\u001B[38;5;73m";
+export declare const AMBER = "\u001B[38;5;214m";
+export declare const SLATE = "\u001B[38;5;245m";
+export declare const ROSE = "\u001B[38;5;204m";
+export declare const LIME = "\u001B[38;5;114m";
+export declare const SKY = "\u001B[38;5;117m";
 export declare const BG_DARK = "\u001B[48;5;236m";
+export declare const BG_DARKER = "\u001B[48;5;234m";
+export declare const BG_PANEL = "\u001B[48;5;237m";
+export declare const BG_HIGHLIGHT = "\u001B[48;5;238m";
+export declare const BOX: {
+    readonly tl: "┌";
+    readonly tr: "┐";
+    readonly bl: "└";
+    readonly br: "┘";
+    readonly h: "─";
+    readonly v: "│";
+    readonly ltee: "├";
+    readonly rtee: "┤";
+    readonly ttee: "┬";
+    readonly btee: "┴";
+    readonly cross: "┼";
+    readonly rtl: "╭";
+    readonly rtr: "╮";
+    readonly rbl: "╰";
+    readonly rbr: "╯";
+};
+export declare const SPINNER: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export declare const DOT: {
+    readonly filled: "●";
+    readonly hollow: "○";
+    readonly half: "◐";
+};
 //# sourceMappingURL=colors.d.ts.map

package/dist/colors.js

@@ -1,12 +1,38 @@
 // shared ANSI color constants — single source of truth for all CLI output
+// basic 16-color
 export const RESET = "\x1b[0m";
 export const BOLD = "\x1b[1m";
 export const DIM = "\x1b[2m";
+export const ITALIC = "\x1b[3m";
 export const RED = "\x1b[31m";
 export const GREEN = "\x1b[32m";
 export const YELLOW = "\x1b[33m";
 export const CYAN = "\x1b[36m";
-export const MAGENTA = "\x1b[35m";
 export const WHITE = "\x1b[37m";
-export const BG_DARK = "\x1b[48;5;236m";
+// 256-color palette — tasteful accents for the TUI
+// use sparingly: these are highlights, not defaults
+export const INDIGO = "\x1b[38;5;105m"; // muted purple-blue for branding
+export const TEAL = "\x1b[38;5;73m"; // cool blue-green for info
+export const AMBER = "\x1b[38;5;214m"; // warm orange for warnings/active
+export const SLATE = "\x1b[38;5;245m"; // neutral gray for secondary text
+export const ROSE = "\x1b[38;5;204m"; // soft red for errors
+export const LIME = "\x1b[38;5;114m"; // fresh green for success/working
+export const SKY = "\x1b[38;5;117m"; // light blue for reasoning
+// background variants (256-color)
+export const BG_DARK = "\x1b[48;5;236m"; // dark gray for header bar
+export const BG_DARKER = "\x1b[48;5;234m"; // near-black for contrast panels
+export const BG_PANEL = "\x1b[48;5;237m"; // subtle panel background
+export const BG_HIGHLIGHT = "\x1b[48;5;238m"; // highlight row
+// box-drawing characters — Unicode block elements
+export const BOX = {
+    tl: "┌", tr: "┐", bl: "└", br: "┘",
+    h: "─", v: "│",
+    ltee: "├", rtee: "┤", ttee: "┬", btee: "┴", cross: "┼",
+    // rounded corners (softer look)
+    rtl: "╭", rtr: "╮", rbl: "╰", rbr: "╯",
+};
+// braille spinner frames for phase animation
+export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+// status dots — filled circle variants
+export const DOT = { filled: "●", hollow: "○", half: "◐" };
 //# sourceMappingURL=colors.js.map

package/dist/config.js

@@ -115,6 +115,32 @@ export function validateConfig(config) {
     if (config.contextFiles !== undefined && !Array.isArray(config.contextFiles)) {
         errors.push(`contextFiles must be an array of file paths, got ${typeof config.contextFiles}`);
     }
+    // claudeCode.yolo and claudeCode.resume must be booleans (string "false" is truthy)
+    if (config.claudeCode?.yolo !== undefined && typeof config.claudeCode.yolo !== "boolean") {
+        errors.push(`claudeCode.yolo must be a boolean, got ${typeof config.claudeCode.yolo}`);
+    }
+    if (config.claudeCode?.resume !== undefined && typeof config.claudeCode.resume !== "boolean") {
+        errors.push(`claudeCode.resume must be a boolean, got ${typeof config.claudeCode.resume}`);
+    }
+    // aoe.profile must be a non-empty string
+    if (config.aoe?.profile !== undefined && (typeof config.aoe.profile !== "string" || !config.aoe.profile)) {
+        errors.push(`aoe.profile must be a non-empty string, got ${JSON.stringify(config.aoe?.profile)}`);
+    }
+    // policies.autoAnswerPermissions must be a boolean
+    if (config.policies?.autoAnswerPermissions !== undefined && typeof config.policies.autoAnswerPermissions !== "boolean") {
+        errors.push(`policies.autoAnswerPermissions must be a boolean, got ${typeof config.policies.autoAnswerPermissions}`);
+    }
+    // policies.userActivityThresholdMs must be a non-negative number
+    if (config.policies?.userActivityThresholdMs !== undefined) {
+        const t = config.policies.userActivityThresholdMs;
+        if (typeof t !== "number" || !isFinite(t) || t < 0) {
+            errors.push(`policies.userActivityThresholdMs must be a number >= 0, got ${t}`);
+        }
+    }
+    // policies.allowDestructive must be a boolean
+    if (config.policies?.allowDestructive !== undefined && typeof config.policies.allowDestructive !== "boolean") {
+        errors.push(`policies.allowDestructive must be a boolean, got ${typeof config.policies.allowDestructive}`);
+    }
     if (errors.length > 0) {
         throw new Error(`invalid config:\n  ${errors.join("\n  ")}`);
     }

package/dist/context.js

@@ -276,7 +276,7 @@ export function resolveProjectDirWithSource(basePath, sessionTitle, sessionDirs)
     }
     return { dir: null, source: null };
 }
-// convenience wrapper — returns just the path (backward compatible)
+// convenience wrapper — returns just the path (used by tests and external callers)
 export function resolveProjectDir(basePath, sessionTitle, sessionDirs) {
     return resolveProjectDirWithSource(basePath, sessionTitle, sessionDirs).dir;
 }

package/dist/init.d.ts

@@ -1,5 +1,5 @@
 import { type ResolutionSource } from "./context.js";
-import type { AoeSession } from "./types.js";
+import { type AoeSession } from "./types.js";
 interface ToolCheck {
     name: string;
     path: string | null;

package/dist/init.js

@@ -15,6 +15,7 @@ import { homedir } from "node:os";
 import { exec } from "./shell.js";
 import { resolveProjectDirWithSource } from "./context.js";
 import { saveTaskState, loadTaskState } from "./task-manager.js";
+import { toSessionStatus } from "./types.js";
 import { createServer } from "node:net";
 import { BOLD, DIM, GREEN, YELLOW, RED, CYAN, RESET } from "./colors.js";
 // check if a tool is on PATH and get its version
@@ -66,7 +67,7 @@ async function getSessionStatus(id) {
         return "unknown";
     try {
         const data = JSON.parse(result.stdout);
-        return String(data.status ?? "unknown");
+        return toSessionStatus(data.status);
     }
     catch {
         return "unknown";

package/dist/poller.d.ts

@@ -1,4 +1,4 @@
-import type { AoaoeConfig, Observation } from "./types.js";
+import { type AoaoeConfig, type Observation } from "./types.js";
 export declare class Poller {
     private config;
     private previousSnapshots;

package/dist/poller.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { exec } from "./shell.js";
 import { loadSessionContext } from "./context.js";
 import { getActivityForSessions } from "./activity.js";
+import { toSessionStatus, } from "./types.js";
 export class Poller {
     config;
     previousSnapshots = new Map();
@@ -112,7 +113,7 @@ export class Poller {
             return "unknown";
         try {
             const data = JSON.parse(result.stdout);
-            return (String(data.status ?? "unknown"));
+            return toSessionStatus(data.status);
         }
         catch {
             return "unknown";
@@ -220,7 +221,6 @@ export function quickHash(s) {
 // covers: CSI (\x1b[...X), OSC (\x1b]...ST), and simple two-char escapes (\x1bX)
 // also strips \x9b (8-bit CSI) sequences
 export function stripAnsi(s) {
-    // eslint-disable-next-line no-control-regex
     return s.replace(/[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[^[\]()#;?0-9A-ORZcf-nqry=><~]/g, "");
 }
 export async function listAoeSessionsShared(timeoutMs = 10_000) {

package/dist/task-manager.js

@@ -172,7 +172,9 @@ export class TaskManager {
             try {
                 sessions = JSON.parse(listResult.stdout);
             }
-            catch { }
+            catch (e) {
+                console.error(`[tasks] failed to parse aoe list output: ${e}`);
+            }
         }
         for (const task of this.tasks) {
             if (task.status === "completed")
@@ -208,7 +210,9 @@ export class TaskManager {
                                 created.push(task.sessionTitle);
                             }
                         }
-                        catch { }
+                        catch (e) {
+                            console.error(`[tasks] failed to parse refreshed session list: ${e}`);
+                        }
                     }
                 }
                 else {

package/dist/tui.d.ts

@@ -1,4 +1,5 @@
 import type { DaemonSessionState, DaemonPhase } from "./types.js";
+declare function phaseDisplay(phase: DaemonPhase, paused: boolean, spinnerFrame: number): string;
 export interface ActivityEntry {
     time: string;
     tag: string;
@@ -17,6 +18,7 @@ export declare class TUI {
     private inputRow;
     private activityBuffer;
     private maxActivity;
+    private spinnerFrame;
     private phase;
     private pollCount;
     private sessions;
@@ -47,17 +49,17 @@ export declare class TUI {
     private repaintActivityRegion;
     private paintInputLine;
 }
+declare function formatSessionCard(s: DaemonSessionState, maxWidth: number): string;
 declare function formatActivity(entry: ActivityEntry, maxCols: number): string;
+declare function padBoxLine(line: string, totalWidth: number): string;
+declare function padToWidth(line: string, totalWidth: number): string;
+declare function stripAnsiForLen(str: string): number;
 declare function truncateAnsi(str: string, maxCols: number): string;
 declare function truncatePlain(str: string, max: number): string;
 /**
  * Format a session state as a plain-English sentence.
- * Examples:
- *   "~ Adventure (opencode) — working on authentication"
- *   "! Cloud Hypervisor (opencode) — error"
- *   ". CHV (claude) — idle"
- *   "~ Adventure (opencode) — you're working here"
+ * Kept for backward compatibility — used by non-TUI output paths.
  */
 export declare function formatSessionSentence(s: DaemonSessionState, maxCols: number): string;
-export { formatActivity, truncateAnsi, truncatePlain };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay };
 //# sourceMappingURL=tui.d.ts.map

package/dist/tui.js

@@ -1,4 +1,4 @@
-import { BOLD, DIM, RESET, GREEN, YELLOW, RED, CYAN, WHITE, BG_DARK } from "./colors.js";
+import { BOLD, DIM, RESET, GREEN, CYAN, WHITE, BG_DARK, INDIGO, TEAL, AMBER, SLATE, ROSE, LIME, SKY, BOX, SPINNER, DOT, } from "./colors.js";
 // ── ANSI helpers ────────────────────────────────────────────────────────────
 const ESC = "\x1b";
 const CSI = `${ESC}[`;
@@ -15,15 +15,30 @@ const RESTORE_CURSOR = `${ESC}8`;
 const moveTo = (row, col) => `${CSI}${row};${col}H`;
 const setScrollRegion = (top, bottom) => `${CSI}${top};${bottom}r`;
 const resetScrollRegion = () => `${CSI}r`;
-// status icons
-const STATUS_ICONS = {
-    working: `${GREEN}~${RESET}`,
-    idle: `${DIM}.${RESET}`,
-    waiting: `${YELLOW}~${RESET}`,
-    done: `${GREEN}+${RESET}`,
-    error: `${RED}!${RESET}`,
-    stopped: `${DIM}x${RESET}`,
+// ── Status rendering ────────────────────────────────────────────────────────
+const STATUS_DOT = {
+    working: `${LIME}${DOT.filled}${RESET}`,
+    running: `${LIME}${DOT.filled}${RESET}`,
+    idle: `${SLATE}${DOT.hollow}${RESET}`,
+    waiting: `${AMBER}${DOT.half}${RESET}`,
+    done: `${GREEN}${DOT.filled}${RESET}`,
+    error: `${ROSE}${DOT.filled}${RESET}`,
+    stopped: `${SLATE}${DOT.hollow}${RESET}`,
 };
+// phase colors and labels
+function phaseDisplay(phase, paused, spinnerFrame) {
+    if (paused)
+        return `${AMBER}${BOLD}PAUSED${RESET}`;
+    const frame = SPINNER[spinnerFrame % SPINNER.length];
+    switch (phase) {
+        case "reasoning": return `${SKY}${frame} reasoning${RESET}`;
+        case "executing": return `${AMBER}${frame} executing${RESET}`;
+        case "polling": return `${LIME}${frame} polling${RESET}`;
+        case "interrupted": return `${ROSE}${BOLD}interrupted${RESET}`;
+        case "sleeping": return `${SLATE}sleeping${RESET}`;
+        default: return `${SLATE}${phase}${RESET}`;
+    }
+}
 // ── TUI class ───────────────────────────────────────────────────────────────
 export class TUI {
     active = false;
@@ -31,13 +46,14 @@ export class TUI {
     cols = 80;
     rows = 24;
     headerHeight = 1; // top bar
-    sessionRows = 0; // dynamic based on session count
+    sessionRows = 0; // dynamic: 2 (borders) + N sessions
     separatorRow = 0; // line between sessions and activity
     scrollTop = 0; // first row of scroll region
     scrollBottom = 0; // last row of scroll region
     inputRow = 0; // bottom input line
     activityBuffer = []; // ring buffer for activity log
     maxActivity = 500; // max entries to keep
+    spinnerFrame = 0; // current spinner animation frame
     // current state for repaints
     phase = "sleeping";
     pollCount = 0;
@@ -56,12 +72,16 @@ export class TUI {
         process.stderr.write(ALT_SCREEN_ON + CURSOR_HIDE + CLEAR_SCREEN);
         // handle terminal resize
         process.stdout.on("resize", () => this.onResize());
-        // repaint header every second so countdown timer ticks down
+        // tick timer: countdown + spinner animation (~4 fps for smooth braille spin)
         this.countdownTimer = setInterval(() => {
-            if (this.active && this.phase === "sleeping" && this.nextTickAt > 0) {
+            if (!this.active)
+                return;
+            this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER.length;
+            // repaint header for countdown and spinner
+            if (this.phase !== "sleeping" || this.nextTickAt > 0) {
                 this.paintHeader();
             }
-        }, 1000);
+        }, 250);
         // initial layout
         this.computeLayout(0);
         this.paintAll();
@@ -129,8 +149,10 @@ export class TUI {
     computeLayout(sessionCount) {
         this.updateDimensions();
         // header: 1 row
-        // sessions: 1 header + N sessions + 1 blank = N+2 rows (min 2 if no sessions)
-        this.sessionRows = Math.max(sessionCount, 0) + 2;
+        // 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;
@@ -138,7 +160,6 @@ export class TUI {
         this.scrollTop = this.separatorRow + 1;
         this.scrollBottom = this.rows - 1;
         if (this.active) {
-            // set scroll region so activity log scrolls within bounds
             process.stderr.write(setScrollRegion(this.scrollTop, this.scrollBottom));
         }
     }
@@ -159,54 +180,64 @@ export class TUI {
         this.paintInputLine();
     }
     paintHeader() {
-        const phaseText = this.paused
-            ? `${YELLOW}PAUSED${RESET}`
-            : this.phase === "reasoning"
-                ? `${CYAN}reasoning...${RESET}`
-                : this.phase === "executing"
-                    ? `${YELLOW}executing...${RESET}`
-                    : this.phase === "polling"
-                        ? `${GREEN}polling${RESET}`
-                        : `${DIM}sleeping${RESET}`;
-        const sessCount = `${this.sessions.length} session${this.sessions.length !== 1 ? "s" : ""}`;
+        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 ? `  ${DIM}|${RESET}  ${YELLOW}${activeCount} user active${RESET}` : "";
+        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 = `  ${DIM}|${RESET}  ${DIM}next: ${remaining}s${RESET}`;
+            countdownTag = `  ${SLATE}│${RESET}  ${SLATE}${remaining}s${RESET}`;
         }
-        // reasoner name
-        const reasonerTag = this.reasonerName ? `  ${DIM}|${RESET}  ${DIM}${this.reasonerName}${RESET}` : "";
-        const line = ` ${BOLD}aoaoe${RESET} ${DIM}${this.version}${RESET}  ${DIM}|${RESET}  poll #${this.pollCount}  ${DIM}|${RESET}  ${sessCount}  ${DIM}|${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) + RESET +
+            moveTo(1, 1) + CLEAR_LINE + BG_DARK + WHITE + truncateAnsi(line, this.cols) + padToWidth(line, this.cols) + RESET +
             RESTORE_CURSOR);
     }
     paintSessions() {
         const startRow = this.headerHeight + 1;
-        // session header — friendly label instead of column abbreviations
-        const hdr = `  ${DIM}agents:${RESET}`;
-        process.stderr.write(SAVE_CURSOR + moveTo(startRow, 1) + CLEAR_LINE + hdr);
-        for (let i = 0; i < this.sessions.length; i++) {
-            const s = this.sessions[i];
-            const line = `  ${formatSessionSentence(s, this.cols - 4)}`;
-            process.stderr.write(moveTo(startRow + 1 + i, 1) + CLEAR_LINE + line);
+        const innerWidth = this.cols - 2; // inside the box borders
+        // top border with label
+        const label = " agents ";
+        const borderAfterLabel = Math.max(0, innerWidth - label.length);
+        const topBorder = `${SLATE}${BOX.rtl}${BOX.h}${RESET}${SLATE}${label}${RESET}${SLATE}${BOX.h.repeat(borderAfterLabel)}${BOX.rtr}${RESET}`;
+        process.stderr.write(SAVE_CURSOR + moveTo(startRow, 1) + CLEAR_LINE + truncateAnsi(topBorder, this.cols));
+        if (this.sessions.length === 0) {
+            // empty state
+            const empty = `${SLATE}${BOX.v}${RESET}  ${DIM}no agents connected${RESET}`;
+            const padded = padBoxLine(empty, this.cols);
+            process.stderr.write(moveTo(startRow + 1, 1) + CLEAR_LINE + padded);
+        }
+        else {
+            for (let i = 0; i < this.sessions.length; i++) {
+                const s = this.sessions[i];
+                const line = `${SLATE}${BOX.v}${RESET} ${formatSessionCard(s, innerWidth - 1)}`;
+                const padded = padBoxLine(line, this.cols);
+                process.stderr.write(moveTo(startRow + 1 + i, 1) + CLEAR_LINE + padded);
+            }
         }
-        // clear any leftover rows if session count decreased
-        const totalSessionLines = this.sessions.length + 1; // +1 for header
-        for (let r = startRow + totalSessionLines; r < this.separatorRow; r++) {
+        // bottom border
+        const bodyRows = Math.max(this.sessions.length, 1);
+        const bottomRow = startRow + 1 + bodyRows;
+        const bottomBorder = `${SLATE}${BOX.rbl}${BOX.h.repeat(Math.max(0, this.cols - 2))}${BOX.rbr}${RESET}`;
+        process.stderr.write(moveTo(bottomRow, 1) + CLEAR_LINE + truncateAnsi(bottomBorder, this.cols));
+        // clear any leftover rows below the box
+        for (let r = bottomRow + 1; r < this.separatorRow; r++) {
             process.stderr.write(moveTo(r, 1) + CLEAR_LINE);
         }
         process.stderr.write(RESTORE_CURSOR);
     }
     paintSeparator() {
-        const hints = " ESC ESC: interrupt  /help  /explain  /pause ";
-        const prefix = "── activity ";
-        const totalDecor = prefix.length + hints.length + 2; // 2 for surrounding ──
-        const fill = Math.max(0, this.cols - totalDecor);
-        const line = `${DIM}${prefix}${"─".repeat(Math.floor(fill / 2))}${hints}${"─".repeat(Math.ceil(fill / 2))}${RESET}`;
+        const hints = " esc esc: interrupt  /help  /explain  /pause ";
+        const prefix = `${BOX.h}${BOX.h} activity `;
+        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);
     }
     writeActivityLine(entry) {
@@ -219,7 +250,6 @@ export class TUI {
         this.paintInputLine();
     }
     repaintActivityRegion() {
-        // repaint visible portion of activity buffer
         const visibleLines = this.scrollBottom - this.scrollTop + 1;
         const entries = this.activityBuffer.slice(-visibleLines);
         for (let i = 0; i < visibleLines; i++) {
@@ -234,25 +264,62 @@ export class TUI {
         }
     }
     paintInputLine() {
+        // phase-aware prompt styling
+        const prompt = this.paused
+            ? `${AMBER}${BOLD}paused >${RESET} `
+            : this.phase === "reasoning"
+                ? `${SKY}thinking >${RESET} `
+                : `${LIME}>${RESET} `;
         process.stderr.write(SAVE_CURSOR +
-            moveTo(this.inputRow, 1) + CLEAR_LINE +
-            `${GREEN}you >${RESET} ` +
+            moveTo(this.inputRow, 1) + CLEAR_LINE + prompt +
             RESTORE_CURSOR);
     }
 }
 // ── Formatting helpers ──────────────────────────────────────────────────────
+// format a session as a card-style line (inside the box)
+function formatSessionCard(s, maxWidth) {
+    const dot = STATUS_DOT[s.status] ?? `${AMBER}${DOT.filled}${RESET}`;
+    const name = `${BOLD}${s.title}${RESET}`;
+    const toolBadge = `${SLATE}${s.tool}${RESET}`;
+    // status description
+    let desc;
+    if (s.userActive) {
+        desc = `${AMBER}you're active${RESET}`;
+    }
+    else if (s.status === "working" || s.status === "running") {
+        desc = s.currentTask
+            ? truncatePlain(s.currentTask, Math.max(20, maxWidth - s.title.length - s.tool.length - 16))
+            : `${LIME}working${RESET}`;
+    }
+    else if (s.status === "idle" || s.status === "stopped") {
+        desc = `${SLATE}idle${RESET}`;
+    }
+    else if (s.status === "error") {
+        desc = `${ROSE}error${RESET}`;
+    }
+    else if (s.status === "done") {
+        desc = `${GREEN}done${RESET}`;
+    }
+    else if (s.status === "waiting") {
+        desc = `${AMBER}waiting${RESET}`;
+    }
+    else {
+        desc = `${SLATE}${s.status}${RESET}`;
+    }
+    return truncateAnsi(`${dot} ${name} ${toolBadge} ${SLATE}${BOX.h}${RESET} ${desc}`, maxWidth);
+}
 // colorize an activity entry based on its tag
 function formatActivity(entry, maxCols) {
     const { time, tag, text } = entry;
-    let color = DIM;
+    let color = SLATE;
     let prefix = tag;
     switch (tag) {
         case "observation":
-            color = DIM;
+            color = SLATE;
             prefix = "obs";
             break;
         case "reasoner":
-            color = CYAN;
+            color = SKY;
             break;
         case "explain":
             color = `${BOLD}${CYAN}`;
@@ -260,30 +327,46 @@ function formatActivity(entry, maxCols) {
             break;
         case "+ action":
         case "action":
-            color = YELLOW;
-            prefix = "+ action";
+            color = AMBER;
+            prefix = "→ action";
             break;
         case "! action":
         case "error":
-            color = RED;
-            prefix = "! action";
+            color = ROSE;
+            prefix = "✗ error";
             break;
         case "you":
-            color = GREEN;
+            color = LIME;
             break;
         case "system":
-            color = DIM;
+            color = SLATE;
             break;
         case "status":
-            color = DIM;
+            color = SLATE;
             break;
         default:
-            color = DIM;
+            color = SLATE;
             break;
     }
-    const formatted = `  ${DIM}${time}${RESET} ${color}[${prefix}]${RESET} ${text}`;
+    const formatted = `  ${SLATE}${time}${RESET} ${color}${prefix}${RESET} ${DIM}│${RESET} ${text}`;
     return truncateAnsi(formatted, maxCols);
 }
+// pad a box line to end with the right border character
+function padBoxLine(line, totalWidth) {
+    const visible = stripAnsiForLen(line);
+    const pad = Math.max(0, totalWidth - visible - 1); // -1 for closing border
+    return line + " ".repeat(pad) + `${SLATE}${BOX.v}${RESET}`;
+}
+// pad the header bar to fill the full width with background color
+function padToWidth(line, totalWidth) {
+    const visible = stripAnsiForLen(line);
+    const pad = Math.max(0, totalWidth - visible);
+    return " ".repeat(pad);
+}
+// count visible characters (strip ANSI escapes)
+function stripAnsiForLen(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
 // truncate a string with ANSI codes to fit a column width (approximate)
 function truncateAnsi(str, maxCols) {
     // strip ANSI to count visible chars
@@ -299,46 +382,41 @@ function truncatePlain(str, max) {
 }
 /**
  * Format a session state as a plain-English sentence.
- * Examples:
- *   "~ Adventure (opencode) — working on authentication"
- *   "! Cloud Hypervisor (opencode) — error"
- *   ". CHV (claude) — idle"
- *   "~ Adventure (opencode) — you're working here"
+ * Kept for backward compatibility — used by non-TUI output paths.
  */
 export function formatSessionSentence(s, maxCols) {
-    const icon = STATUS_ICONS[s.status] ?? `${YELLOW}?${RESET}`;
+    const dot = STATUS_DOT[s.status] ?? `${AMBER}${DOT.filled}${RESET}`;
     const name = s.title;
-    const tool = `${DIM}(${s.tool})${RESET}`;
-    // human-readable status descriptions
+    const tool = `${SLATE}(${s.tool})${RESET}`;
     let statusDesc;
     if (s.userActive) {
-        statusDesc = `${YELLOW}you're working here${RESET}`;
+        statusDesc = `${AMBER}you're working here${RESET}`;
     }
     else if (s.status === "working") {
         if (s.currentTask) {
             statusDesc = truncatePlain(s.currentTask, Math.max(30, maxCols - name.length - s.tool.length - 20));
         }
         else {
-            statusDesc = `${GREEN}working${RESET}`;
+            statusDesc = `${LIME}working${RESET}`;
         }
     }
     else if (s.status === "idle" || s.status === "stopped") {
-        statusDesc = `${DIM}idle${RESET}`;
+        statusDesc = `${SLATE}idle${RESET}`;
     }
     else if (s.status === "error") {
-        statusDesc = `${RED}hit an error${RESET}`;
+        statusDesc = `${ROSE}hit an error${RESET}`;
     }
     else if (s.status === "done") {
         statusDesc = `${GREEN}finished${RESET}`;
     }
     else if (s.status === "waiting") {
-        statusDesc = `${YELLOW}waiting for input${RESET}`;
+        statusDesc = `${AMBER}waiting for input${RESET}`;
     }
     else {
         statusDesc = s.status;
     }
-    return truncateAnsi(`${icon} ${BOLD}${name}${RESET} ${tool} ${DIM}—${RESET} ${statusDesc}`, maxCols);
+    return truncateAnsi(`${dot} ${BOLD}${name}${RESET} ${tool} ${SLATE}—${RESET} ${statusDesc}`, maxCols);
 }
 // ── Exported pure helpers (for testing) ─────────────────────────────────────
-export { formatActivity, truncateAnsi, truncatePlain };
+export { formatActivity, formatSessionCard, truncateAnsi, truncatePlain, padBoxLine, padToWidth, stripAnsiForLen, phaseDisplay };
 //# sourceMappingURL=tui.js.map

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 export type AoeSessionStatus = "working" | "running" | "idle" | "waiting" | "done" | "error" | "stopped" | "unknown";
+export declare function toSessionStatus(raw: unknown): AoeSessionStatus;
 export interface AoeSession {
     id: string;
     title: string;

package/dist/types.js

@@ -1,3 +1,9 @@
+const VALID_STATUSES = new Set(["working", "running", "idle", "waiting", "done", "error", "stopped", "unknown"]);
+// coerce an arbitrary string (e.g. from CLI JSON output) to a valid AoeSessionStatus
+export function toSessionStatus(raw) {
+    const s = String(raw ?? "unknown");
+    return VALID_STATUSES.has(s) ? s : "unknown";
+}
 // extract the session/title identifier from any action (uses discriminated union narrowing)
 export function actionSession(action) {
     switch (action.action) {

package/package.json

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