aoaoe 0.51.0 → 0.53.0

package/README.md

@@ -238,6 +238,9 @@ aoaoe [command] [options]
 commands:
   (none)         start the supervisor daemon (interactive TUI)
   init           detect tools + sessions, import history, generate config
+  status         quick daemon health check (is it running? what's it doing?)
+  config         show the effective resolved config (defaults + file)
+  notify-test    send a test notification to configured webhooks
   task           manage tasks and sessions (list, start, stop, new, rm, edit)
   tasks          show task progress (from aoaoe.tasks.json)
   history        review recent actions (from ~/.aoaoe/actions.log)
@@ -297,7 +300,12 @@ Config lives at `~/.aoaoe/aoaoe.config.json` (canonical, written by `aoaoe init`
     "adventure": "github/adventure",
     "cloudchamber": "cc/cloudchamber"
   },
-  "contextFiles": []
+  "contextFiles": [],
+  "notifications": {
+    "webhookUrl": "https://example.com/webhook",
+    "slackWebhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
+    "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"]
+  }
 }
 ```
 
@@ -321,6 +329,9 @@ Config lives at `~/.aoaoe/aoaoe.config.json` (canonical, written by `aoaoe init`
 | `sessionDirs` | Map session titles to project directories (relative to cwd or absolute). Bypasses heuristic directory search. | `{}` |
 | `contextFiles` | Extra AI instruction file paths to load from each project root | `[]` |
 | `captureLinesCount` | Number of tmux lines to capture per session (`-S` flag) | `100` |
+| `notifications.webhookUrl` | Generic webhook URL (POST JSON) | (none) |
+| `notifications.slackWebhookUrl` | Slack incoming webhook URL (block kit format) | (none) |
+| `notifications.events` | Filter which events fire (omit to send all). Valid: `session_error`, `session_done`, `action_executed`, `action_failed`, `daemon_started`, `daemon_stopped` | (all) |
 
 Also reads `.aoaoe.json` as an alternative config filename.
 
@@ -342,7 +353,25 @@ For non-standard layouts or when the session title doesn't match the directory n
 
 Paths can be relative (resolved from the directory where you run `aoaoe`) or absolute. Case-insensitive matching is used for session title lookup. If a mapped path doesn't exist on disk, aoaoe falls back to heuristic search.
 
-Use `aoaoe test-context` to verify resolution:
+Use `aoaoe test-context` to verify resolution.
+
+### `notifications` — webhook alerts for daemon events
+
+aoaoe can send webhook notifications when significant events occur (session errors, task completions, daemon start/stop). Supports generic JSON webhooks and Slack incoming webhooks with block kit formatting.
+
+```json
+{
+  "notifications": {
+    "webhookUrl": "https://example.com/webhook",
+    "slackWebhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
+    "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"]
+  }
+}
+```
+
+Both webhook URLs are optional — configure one or both. The `events` array filters which event types fire (omit it to receive all events). Notifications are fire-and-forget with a 5s timeout and 60s rate limiting per event+session combo to prevent spam.
+
+Run `aoaoe notify-test` to verify your webhook configuration.
 
 ## How It Works
 
@@ -460,6 +489,7 @@ src/
   tui.ts            # in-place terminal UI (alternate screen, scroll regions)
   input.ts          # stdin readline listener with inject() for post-interrupt
   init.ts           # `aoaoe init`: auto-discover tools, sessions, generate config
+  notify.ts         # webhook + Slack notification dispatcher for daemon events
   colors.ts         # shared ANSI color/style constants
   context.ts        # discoverContextFiles, resolveProjectDir, loadSessionContext
   activity.ts       # detect human keystrokes in tmux sessions

package/dist/config.d.ts

@@ -20,6 +20,7 @@ export declare function parseCliArgs(argv: string[]): {
     showHistory: boolean;
     showStatus: boolean;
     showConfig: boolean;
+    notifyTest: boolean;
     runInit: boolean;
     initForce: boolean;
     runTaskCli: boolean;

package/dist/config.js

@@ -91,6 +91,7 @@ const KNOWN_KEYS = {
         "maxIdleBeforeNudgeMs", "maxErrorsBeforeRestart", "autoAnswerPermissions",
         "actionCooldownMs", "userActivityThresholdMs", "allowDestructive",
     ]),
+    notifications: new Set(["webhookUrl", "slackWebhookUrl", "events"]),
 };
 export function warnUnknownKeys(raw, source) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -182,6 +183,34 @@ export function validateConfig(config) {
     if (config.policies?.allowDestructive !== undefined && typeof config.policies.allowDestructive !== "boolean") {
         errors.push(`policies.allowDestructive must be a boolean, got ${typeof config.policies.allowDestructive}`);
     }
+    // notifications.webhookUrl must be a string starting with http:// or https://
+    if (config.notifications?.webhookUrl !== undefined) {
+        const u = config.notifications.webhookUrl;
+        if (typeof u !== "string" || (!u.startsWith("http://") && !u.startsWith("https://"))) {
+            errors.push(`notifications.webhookUrl must be a URL starting with http:// or https://, got ${JSON.stringify(u)}`);
+        }
+    }
+    // notifications.slackWebhookUrl must be a string starting with http:// or https://
+    if (config.notifications?.slackWebhookUrl !== undefined) {
+        const u = config.notifications.slackWebhookUrl;
+        if (typeof u !== "string" || (!u.startsWith("http://") && !u.startsWith("https://"))) {
+            errors.push(`notifications.slackWebhookUrl must be a URL starting with http:// or https://, got ${JSON.stringify(u)}`);
+        }
+    }
+    // notifications.events must be an array of valid NotificationEvent values
+    if (config.notifications?.events !== undefined) {
+        const VALID_EVENTS = new Set(["session_error", "session_done", "action_executed", "action_failed", "daemon_started", "daemon_stopped"]);
+        if (!Array.isArray(config.notifications.events)) {
+            errors.push(`notifications.events must be an array, got ${typeof config.notifications.events}`);
+        }
+        else {
+            for (const e of config.notifications.events) {
+                if (!VALID_EVENTS.has(e)) {
+                    errors.push(`notifications.events contains invalid event "${e}"`);
+                }
+            }
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`invalid config:\n  ${errors.join("\n  ")}`);
     }
@@ -245,7 +274,7 @@ export function parseCliArgs(argv) {
     let initForce = false;
     let runTaskCli = false;
     let registerTitle;
-    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, runInit: false, initForce: false, runTaskCli: false };
+    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, notifyTest: false, runInit: false, initForce: false, runTaskCli: false };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -268,6 +297,9 @@ export function parseCliArgs(argv) {
     if (argv[2] === "config") {
         return { ...defaults, showConfig: true };
     }
+    if (argv[2] === "notify-test") {
+        return { ...defaults, notifyTest: true };
+    }
     if (argv[2] === "init") {
         const force = argv.includes("--force") || argv.includes("-f");
         return { ...defaults, runInit: true, initForce: force };
@@ -357,7 +389,7 @@ export function parseCliArgs(argv) {
                 break;
         }
     }
-    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, runInit: false, initForce: false, runTaskCli: false };
+    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, notifyTest: false, runInit: false, initForce: false, runTaskCli: false };
 }
 export function printHelp() {
     console.log(`aoaoe - autonomous supervisor for agent-of-empires sessions
@@ -375,6 +407,7 @@ commands:
   (none)         start the supervisor daemon (interactive TUI)
   status         quick daemon health check (is it running? what's it doing?)
   config         show the effective resolved config (defaults + file)
+  notify-test    send a test notification to configured webhooks
   task           manage tasks and sessions (list, start, stop, new, rm, edit)
   tasks          show task progress (from aoaoe.tasks.json)
   history        review recent actions (from ~/.aoaoe/actions.log)
@@ -417,6 +450,11 @@ example config:
     "sessionDirs": {
       "my-project": "/path/to/my-project",
       "other-repo": "/path/to/other-repo"
+    },
+    "notifications": {
+      "webhookUrl": "https://example.com/webhook",
+      "slackWebhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
+      "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"]
     }
   }
 
@@ -424,6 +462,10 @@ example config:
   aoaoe loads AGENTS.md, claude.md, and other AI instruction files
   from each project directory to give the reasoner per-session context.
 
+  notifications sends webhook alerts for daemon events. Both webhookUrl
+  and slackWebhookUrl are optional. events filters which events fire
+  (omit to send all). Run 'aoaoe notify-test' to verify delivery.
+
 interactive commands (while daemon is running):
   /help          show available commands
   /explain       ask the AI to explain what's happening in plain English

package/dist/index.js

@@ -17,6 +17,7 @@ import { TaskManager, loadTaskDefinitions, loadTaskState, formatTaskTable } from
 import { runTaskCli, handleTaskSlashCommand } from "./task-cli.js";
 import { TUI } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
+import { sendNotification, sendTestNotification } from "./notify.js";
 import { actionSession, actionDetail } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
 import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync, chmodSync } from "node:fs";
@@ -27,7 +28,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const AOAOE_DIR = join(homedir(), ".aoaoe"); // watch dir for wakeable sleep
 const INPUT_FILE = join(AOAOE_DIR, "pending-input.txt"); // file IPC from chat.ts
 async function main() {
-    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, runInit, initForce, runTaskCli: isTaskCli, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, notifyTest, runInit, initForce, runTaskCli: isTaskCli, registerTitle } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -77,6 +78,11 @@ async function main() {
         showEffectiveConfig();
         return;
     }
+    // `aoaoe notify-test` -- send a test notification to configured webhooks
+    if (notifyTest) {
+        await runNotifyTest();
+        return;
+    }
     // `aoaoe task` -- task management CLI
     if (isTaskCli) {
         await runTaskCli(process.argv);
@@ -284,6 +290,8 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        // notify: daemon stopped (fire-and-forget, don't block shutdown)
+        sendNotification(config, { event: "daemon_stopped", timestamp: Date.now(), detail: `polls: ${totalPolls}, actions: ${totalActionsExecuted}` });
         input.stop();
         Promise.resolve()
             .then(() => reasonerConsole.stop())
@@ -307,6 +315,8 @@ async function main() {
     else {
         log("entering main loop (Ctrl+C to stop)\n");
     }
+    // notify: daemon started
+    sendNotification(config, { event: "daemon_started", timestamp: Date.now(), detail: `reasoner: ${config.reasoner}` });
     // clear any stale interrupt from a previous run
     clearInterrupt();
     // auto-explain: on the very first tick with sessions, inject an explain prompt
@@ -680,6 +690,19 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
             }
         }
     }
+    // notify: session error/done events (fires for both TUI and non-TUI modes)
+    {
+        const changedSet = new Set(observation.changes.map((c) => c.title));
+        for (const snap of observation.sessions) {
+            const s = snap.session;
+            if (s.status === "error" && changedSet.has(s.title)) {
+                sendNotification(config, { event: "session_error", timestamp: Date.now(), session: s.title, detail: `status: ${s.status}` });
+            }
+            if (s.status === "done" && changedSet.has(s.title)) {
+                sendNotification(config, { event: "session_done", timestamp: Date.now(), session: s.title });
+            }
+        }
+    }
     if (skippedReason === "no changes") {
         if (config.verbose) {
             if (tui)
@@ -750,6 +773,13 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
             log(`[${icon}] ${displayText}`);
         }
         reasonerConsole.writeAction(entry.action.action, richDetail, entry.success);
+        // notify: action executed or failed
+        sendNotification(config, {
+            event: entry.success ? "action_executed" : "action_failed",
+            timestamp: Date.now(),
+            session: sessionTitle,
+            detail: `${entry.action.action}${actionText ? `: ${actionText.slice(0, 200)}` : ""}`,
+        });
     }
     const actionsOk = executed.filter((e) => e.success && e.action.action !== "wait").length;
     const actionsFail = executed.filter((e) => !e.success && e.action.action !== "wait").length;
@@ -1016,6 +1046,43 @@ async function registerAsAoeSession(title) {
     console.log();
     console.log(`or start + enter immediately: aoe session start ${sessionTitle} && aoe`);
 }
+// `aoaoe notify-test` -- send a test notification to all configured webhooks and report results
+async function runNotifyTest() {
+    const config = loadConfig();
+    if (!config.notifications) {
+        console.log("");
+        console.log("  no notifications configured.");
+        console.log("");
+        console.log("  add to your config (~/.aoaoe/aoaoe.config.json):");
+        console.log('    "notifications": {');
+        console.log('      "webhookUrl": "https://example.com/webhook",');
+        console.log('      "slackWebhookUrl": "https://hooks.slack.com/services/...",');
+        console.log('      "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"]');
+        console.log("    }");
+        console.log("");
+        return;
+    }
+    if (!config.notifications.webhookUrl && !config.notifications.slackWebhookUrl) {
+        console.log("");
+        console.log("  notifications block exists but no webhook URLs configured.");
+        console.log("  add webhookUrl and/or slackWebhookUrl to your notifications config.");
+        console.log("");
+        return;
+    }
+    console.log("");
+    console.log("  sending test notification...");
+    const result = await sendTestNotification(config);
+    console.log("");
+    if (result.webhookOk !== undefined) {
+        const icon = result.webhookOk ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+        console.log(`  ${icon} generic webhook: ${result.webhookOk ? "ok" : result.webhookError ?? "failed"}`);
+    }
+    if (result.slackOk !== undefined) {
+        const icon = result.slackOk ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+        console.log(`  ${icon} slack webhook:   ${result.slackOk ? "ok" : result.slackError ?? "failed"}`);
+    }
+    console.log("");
+}
 function readPkgVersion() {
     try {
         const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));

package/dist/init.js

@@ -291,6 +291,7 @@ export async function runInit(forceOverwrite = false) {
         console.log(`     ${CYAN}aoaoe${RESET}`);
     }
     console.log(`\n  ${DIM}tip: run ${BOLD}aoaoe test-context${RESET}${DIM} to verify session discovery without starting the daemon${RESET}`);
+    console.log(`  ${DIM}tip: add a "notifications" block to your config for webhook alerts (see ${BOLD}aoaoe --help${RESET}${DIM})${RESET}`);
     console.log();
     return { tools, sessions, reasoner, opencodePort, opencodeRunning, configPath, wrote: true };
 }

package/dist/notify.d.ts

@@ -0,0 +1,21 @@
+import type { AoaoeConfig, NotificationEvent } from "./types.js";
+export interface NotificationPayload {
+    event: NotificationEvent;
+    timestamp: number;
+    session?: string;
+    detail?: string;
+}
+export declare function isRateLimited(payload: NotificationPayload, now?: number): boolean;
+export declare function resetRateLimiter(): void;
+export declare function sendNotification(config: AoaoeConfig, payload: NotificationPayload): Promise<void>;
+export declare function sendTestNotification(config: AoaoeConfig): Promise<{
+    webhookOk?: boolean;
+    slackOk?: boolean;
+    webhookError?: string;
+    slackError?: string;
+}>;
+export declare function formatSlackPayload(payload: NotificationPayload): {
+    text: string;
+    blocks: object[];
+};
+//# sourceMappingURL=notify.d.ts.map

package/dist/notify.js

@@ -0,0 +1,191 @@
+// ── rate limiting ───────────────────────────────────────────────────────────
+// dedup key: "event:session" — prevents spam when sessions rapidly error/recover.
+// default window: 60s per unique event+session combo.
+const RATE_LIMIT_MS = 60_000;
+const recentNotifications = new Map(); // key → last-sent timestamp
+function rateLimitKey(payload) {
+    return `${payload.event}:${payload.session ?? ""}`;
+}
+// exported for testing
+export function isRateLimited(payload, now) {
+    const key = rateLimitKey(payload);
+    const lastSent = recentNotifications.get(key);
+    const ts = now ?? Date.now();
+    if (lastSent !== undefined && ts - lastSent < RATE_LIMIT_MS)
+        return true;
+    return false;
+}
+function recordSent(payload, now) {
+    const key = rateLimitKey(payload);
+    recentNotifications.set(key, now ?? Date.now());
+    // prune old entries to prevent unbounded growth (keep last 200)
+    if (recentNotifications.size > 200) {
+        const cutoff = (now ?? Date.now()) - RATE_LIMIT_MS;
+        for (const [k, v] of recentNotifications) {
+            if (v < cutoff)
+                recentNotifications.delete(k);
+        }
+    }
+}
+// exported for testing — reset rate limiter state between tests
+export function resetRateLimiter() {
+    recentNotifications.clear();
+}
+// send a notification to all configured webhooks.
+// fire-and-forget: never throws, never blocks the daemon.
+// rate-limited: suppresses duplicate event+session combos within 60s.
+export async function sendNotification(config, payload) {
+    const n = config.notifications;
+    if (!n)
+        return;
+    // filter: only send if event is in the configured list (or no filter = send all)
+    if (n.events && n.events.length > 0 && !n.events.includes(payload.event))
+        return;
+    // rate limit: skip if we sent the same event+session recently
+    if (isRateLimited(payload))
+        return;
+    recordSent(payload);
+    const promises = [];
+    if (n.webhookUrl) {
+        promises.push(sendGenericWebhook(n.webhookUrl, payload));
+    }
+    if (n.slackWebhookUrl) {
+        promises.push(sendSlackWebhook(n.slackWebhookUrl, payload));
+    }
+    // fire-and-forget — swallow all errors so the daemon never crashes on notification failure
+    await Promise.allSettled(promises);
+}
+// send a test notification and return whether delivery succeeded.
+// unlike sendNotification, this is NOT fire-and-forget — it reports errors.
+export async function sendTestNotification(config) {
+    const n = config.notifications;
+    if (!n)
+        return {};
+    const payload = {
+        event: "daemon_started",
+        timestamp: Date.now(),
+        detail: "test notification from aoaoe notify-test",
+    };
+    const result = {};
+    if (n.webhookUrl) {
+        try {
+            const resp = await fetch(n.webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ event: payload.event, timestamp: payload.timestamp, detail: payload.detail }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            result.webhookOk = resp.ok;
+            if (!resp.ok)
+                result.webhookError = `HTTP ${resp.status} ${resp.statusText}`;
+        }
+        catch (err) {
+            result.webhookOk = false;
+            result.webhookError = String(err);
+        }
+    }
+    if (n.slackWebhookUrl) {
+        try {
+            const body = formatSlackPayload(payload);
+            const resp = await fetch(n.slackWebhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(10_000),
+            });
+            result.slackOk = resp.ok;
+            if (!resp.ok)
+                result.slackError = `HTTP ${resp.status} ${resp.statusText}`;
+        }
+        catch (err) {
+            result.slackOk = false;
+            result.slackError = String(err);
+        }
+    }
+    return result;
+}
+// POST JSON payload to a generic webhook URL
+async function sendGenericWebhook(url, payload) {
+    try {
+        await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                event: payload.event,
+                timestamp: payload.timestamp,
+                session: payload.session,
+                detail: payload.detail,
+            }),
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch (err) {
+        console.error(`[notify] generic webhook failed: ${err}`);
+    }
+}
+// POST Slack block format to a Slack incoming webhook URL
+async function sendSlackWebhook(url, payload) {
+    try {
+        const body = formatSlackPayload(payload);
+        await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch (err) {
+        console.error(`[notify] slack webhook failed: ${err}`);
+    }
+}
+// format a notification payload into Slack block kit format.
+// exported for testing.
+export function formatSlackPayload(payload) {
+    const icon = eventIcon(payload.event);
+    const title = eventTitle(payload.event);
+    const fallbackText = payload.session
+        ? `${icon} ${title}: ${payload.session}${payload.detail ? ` — ${payload.detail}` : ""}`
+        : `${icon} ${title}${payload.detail ? ` — ${payload.detail}` : ""}`;
+    const blocks = [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${icon} ${title}*${payload.session ? `\n*Session:* ${payload.session}` : ""}${payload.detail ? `\n${payload.detail}` : ""}`,
+            },
+        },
+        {
+            type: "context",
+            elements: [
+                {
+                    type: "mrkdwn",
+                    text: `aoaoe | ${new Date(payload.timestamp).toISOString()}`,
+                },
+            ],
+        },
+    ];
+    return { text: fallbackText, blocks };
+}
+// human-readable title for each event type
+function eventTitle(event) {
+    switch (event) {
+        case "session_error": return "Session Error";
+        case "session_done": return "Session Done";
+        case "action_executed": return "Action Executed";
+        case "action_failed": return "Action Failed";
+        case "daemon_started": return "Daemon Started";
+        case "daemon_stopped": return "Daemon Stopped";
+    }
+}
+// emoji icon for each event type (used in Slack messages)
+function eventIcon(event) {
+    switch (event) {
+        case "session_error": return "\u{1F6A8}"; // 🚨
+        case "session_done": return "\u2705"; // ✅
+        case "action_executed": return "\u2699\uFE0F"; // ⚙️
+        case "action_failed": return "\u274C"; // ❌
+        case "daemon_started": return "\u{1F680}"; // 🚀
+        case "daemon_stopped": return "\u{1F6D1}"; // 🛑
+    }
+}
+//# sourceMappingURL=notify.js.map

package/dist/types.d.ts

@@ -115,7 +115,13 @@ export interface AoaoeConfig {
     dryRun: boolean;
     observe: boolean;
     confirm: boolean;
+    notifications?: {
+        webhookUrl?: string;
+        slackWebhookUrl?: string;
+        events?: NotificationEvent[];
+    };
 }
+export type NotificationEvent = "session_error" | "session_done" | "action_executed" | "action_failed" | "daemon_started" | "daemon_stopped";
 export type DaemonPhase = "sleeping" | "polling" | "reasoning" | "executing" | "interrupted";
 export interface DaemonSessionState {
     id: string;

package/package.json

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