aoaoe 0.47.0 → 0.48.0

package/dist/colors.d.ts

@@ -1,7 +1,6 @@
 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";
@@ -15,9 +14,6 @@ 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: "┐";

package/dist/colors.js

@@ -3,7 +3,6 @@
 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";
@@ -20,9 +19,6 @@ 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: "┘",

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/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.47.0",
+  "version": "0.48.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",