aoaoe 0.46.0 → 0.48.0

package/dist/colors.d.ts

@@ -6,5 +6,35 @@ export declare const GREEN = "\u001B[32m";
 export declare const YELLOW = "\u001B[33m";
 export declare const CYAN = "\u001B[36m";
 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 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,4 +1,5 @@
 // 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";
@@ -7,5 +8,27 @@ export const GREEN = "\x1b[32m";
 export const YELLOW = "\x1b[33m";
 export const CYAN = "\x1b[36m";
 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
+// 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

@@ -3,6 +3,7 @@ import { resolve, join } from "node:path";
 import { homedir } from "node:os";
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
+import { toReasonerBackend } from "./types.js";
 const execFileAsync = promisify(execFileCb);
 const AOAOE_DIR = join(homedir(), ".aoaoe");
 const CONFIG_NAMES = ["aoaoe.config.json", ".aoaoe.json"];
@@ -250,7 +251,7 @@ export function parseCliArgs(argv) {
         const arg = argv[i];
         switch (arg) {
             case "--reasoner":
-                overrides.reasoner = nextArg(i, arg);
+                overrides.reasoner = toReasonerBackend(nextArg(i, arg));
                 i++;
                 break;
             case "--poll-interval": {

package/dist/daemon-state.js

@@ -4,6 +4,7 @@
 import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { toDaemonState } from "./types.js";
 import { parseTasks, formatTaskList } from "./task-parser.js";
 const AOAOE_DIR = join(homedir(), ".aoaoe");
 const STATE_FILE = join(AOAOE_DIR, "daemon-state.json");
@@ -122,7 +123,7 @@ export function readState() {
     try {
         if (!existsSync(STATE_FILE))
             return null;
-        return JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+        return toDaemonState(JSON.parse(readFileSync(STATE_FILE, "utf-8")));
     }
     catch {
         return null;

package/dist/index.js

@@ -467,6 +467,8 @@ async function main() {
             else {
                 // ── normal mode: full tick ─────────────────────────────────────────
                 const activeTaskContext = taskManager ? taskManager.tasks.filter((t) => t.status !== "completed") : undefined;
+                if (!reasoner || !executor)
+                    throw new Error("reasoner/executor unexpectedly null in normal mode");
                 const { interrupted, decisionsThisTick, actionsOk, actionsFail } = await daemonTick(config, poller, reasoner, executor, reasonerConsole, pollCount, policyStates, userMessage, forceDashboard, activeTaskContext, taskManager, tui);
                 totalDecisions += decisionsThisTick;
                 totalActionsExecuted += actionsOk;

package/dist/init.js

@@ -36,7 +36,10 @@ async function discoverSessions() {
     if (result.exitCode !== 0)
         return [];
     try {
-        const raw = JSON.parse(result.stdout);
+        const parsed = JSON.parse(result.stdout);
+        if (!Array.isArray(parsed))
+            return [];
+        const raw = parsed;
         // fetch status for each session in parallel (allSettled so one failure doesn't kill all)
         const results = await Promise.allSettled(raw.map(async (r) => {
             const id = String(r.id ?? "");

package/dist/prompt-watcher.js

@@ -78,7 +78,7 @@ function checkAndClear() {
                 .pop() || '';
               appendFileSync(logFile,
                 new Date().toISOString() + ' CLEARED: ' + line.trim().slice(0, 120) + '\\n');
-            } catch(e) {}
+            } catch {}
           }
         }
       }

package/dist/reasoner/opencode.js

@@ -80,6 +80,8 @@ export class OpencodeReasoner {
         }
     }
     async decideViaSDK(prompt, signal) {
+        if (!this.client)
+            throw new Error("decideViaSDK called without a connected client");
         const client = this.client;
         // create session on first call, after rotation, or after error reset
         if (!this.sessionId) {
@@ -281,7 +283,7 @@ class OpencodeClient {
         // extract text from assistant response parts
         const textParts = (data.parts ?? [])
             .filter((p) => p.type === "text" && p.text)
-            .map((p) => p.text);
+            .map((p) => p.text ?? "");
         return textParts.join("\n");
     }
 }

package/dist/reasoner/prompt.js

@@ -160,7 +160,7 @@ export function formatObservation(obs) {
         parts.push("Project context for sessions:");
         let contextBudget = 50_000; // max bytes for all project context combined
         for (const snap of sortedContextSessions) {
-            const ctx = snap.projectContext;
+            const ctx = snap.projectContext ?? "";
             const ctxBytes = Buffer.byteLength(ctx, "utf-8");
             if (ctxBytes > contextBudget) {
                 // truncate this context to fit remaining budget

package/dist/task-cli.js

@@ -4,6 +4,7 @@ import { exec } from "./shell.js";
 import { existsSync } from "node:fs";
 import { resolve, basename } from "node:path";
 import { loadTaskState, saveTaskState, formatTaskTable } from "./task-manager.js";
+import { toAoeSessionList } from "./types.js";
 import { BOLD, DIM, GREEN, YELLOW, RED, RESET } from "./colors.js";
 // resolve a fuzzy reference to a task: match by title, repo basename, or session ID prefix
 export function resolveTask(ref, tasks) {
@@ -112,7 +113,7 @@ export async function taskNew(title, path, tool = "opencode") {
     let sessionId;
     if (listResult.exitCode === 0) {
         try {
-            const sessions = JSON.parse(listResult.stdout);
+            const sessions = toAoeSessionList(JSON.parse(listResult.stdout));
             const found = sessions.find((s) => s.title.toLowerCase() === lower);
             sessionId = found?.id;
         }

package/dist/task-manager.js

@@ -5,6 +5,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "
 import { join, resolve, basename } from "node:path";
 import { homedir } from "node:os";
 import { exec } from "./shell.js";
+import { toTaskState, toAoeSessionList } from "./types.js";
 import { RESET, BOLD, DIM, GREEN, YELLOW, RED, CYAN } from "./colors.js";
 const AOAOE_DIR = join(homedir(), ".aoaoe");
 const STATE_FILE = join(AOAOE_DIR, "task-state.json");
@@ -84,8 +85,9 @@ export function loadTaskState() {
         const raw = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
         if (raw && typeof raw.tasks === "object") {
             for (const [repo, state] of Object.entries(raw.tasks)) {
-                if (state && typeof state === "object") {
-                    map.set(repo, state);
+                const validated = toTaskState(state);
+                if (validated) {
+                    map.set(repo, validated);
                 }
             }
         }
@@ -138,10 +140,12 @@ export class TaskManager {
             else {
                 // update goal/tool if definition changed (don't reset progress)
                 const existing = this.states.get(def.repo);
-                if (def.goal)
-                    existing.goal = def.goal;
-                if (def.tool)
-                    existing.tool = def.tool;
+                if (existing) {
+                    if (def.goal)
+                        existing.goal = def.goal;
+                    if (def.tool)
+                        existing.tool = def.tool;
+                }
             }
         }
         this.save();
@@ -201,7 +205,7 @@ export class TaskManager {
                     const refreshResult = await exec("aoe", ["list", "--json"]);
                     if (refreshResult.exitCode === 0) {
                         try {
-                            const refreshed = JSON.parse(refreshResult.stdout);
+                            const refreshed = toAoeSessionList(JSON.parse(refreshResult.stdout));
                             const newSession = refreshed.find((s) => s.title.toLowerCase() === task.sessionTitle.toLowerCase());
                             if (newSession) {
                                 task.sessionId = newSession.id;

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

@@ -162,4 +162,11 @@ export interface TaskState {
     completedAt?: number;
     progress: TaskProgress[];
 }
+export declare function toTaskState(raw: unknown): TaskState | null;
+export declare function toDaemonState(raw: unknown): DaemonState | null;
+export declare function toAoeSessionList(raw: unknown): Array<{
+    id: string;
+    title: string;
+}>;
+export declare function toReasonerBackend(raw: string): ReasonerBackend;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -37,4 +37,79 @@ export function actionDetail(action) {
             return undefined;
     }
 }
+const VALID_TASK_STATUSES = new Set(["pending", "active", "completed", "paused", "failed"]);
+// validate an unknown value (e.g. from JSON.parse) as a TaskState, returning null if invalid
+export function toTaskState(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (typeof r.repo !== "string" || !r.repo)
+        return null;
+    if (typeof r.sessionTitle !== "string")
+        return null;
+    if (typeof r.tool !== "string")
+        return null;
+    if (typeof r.goal !== "string")
+        return null;
+    if (typeof r.status !== "string" || !VALID_TASK_STATUSES.has(r.status))
+        return null;
+    if (!Array.isArray(r.progress))
+        return null;
+    return {
+        repo: r.repo,
+        sessionTitle: r.sessionTitle,
+        tool: r.tool,
+        goal: r.goal,
+        status: r.status,
+        sessionId: typeof r.sessionId === "string" ? r.sessionId : undefined,
+        createdAt: typeof r.createdAt === "number" ? r.createdAt : undefined,
+        lastProgressAt: typeof r.lastProgressAt === "number" ? r.lastProgressAt : undefined,
+        completedAt: typeof r.completedAt === "number" ? r.completedAt : undefined,
+        progress: r.progress.filter((p) => !!p && typeof p === "object" &&
+            typeof p.at === "number" &&
+            typeof p.summary === "string"),
+    };
+}
+// validate an unknown value as a DaemonState, returning null if invalid
+export function toDaemonState(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (typeof r.tickStartedAt !== "number")
+        return null;
+    if (typeof r.nextTickAt !== "number")
+        return null;
+    if (typeof r.pollIntervalMs !== "number")
+        return null;
+    if (typeof r.phase !== "string")
+        return null;
+    if (typeof r.phaseStartedAt !== "number")
+        return null;
+    if (typeof r.pollCount !== "number")
+        return null;
+    if (typeof r.paused !== "boolean")
+        return null;
+    if (typeof r.sessionCount !== "number")
+        return null;
+    if (typeof r.changeCount !== "number")
+        return null;
+    if (!Array.isArray(r.sessions))
+        return null;
+    return raw;
+}
+// validate an unknown array as an AoE session list (from `aoe list --json`)
+export function toAoeSessionList(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => !!item && typeof item === "object" &&
+        typeof item.id === "string" &&
+        typeof item.title === "string");
+}
+// validate a string as a ReasonerBackend, throwing on invalid input
+const VALID_REASONER_BACKENDS = new Set(["opencode", "claude-code"]);
+export function toReasonerBackend(raw) {
+    if (VALID_REASONER_BACKENDS.has(raw))
+        return raw;
+    throw new Error(`--reasoner must be "opencode" or "claude-code", got "${raw}"`);
+}
 //# sourceMappingURL=types.js.map

package/package.json

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