aoaoe 0.50.0 → 0.52.0

package/dist/chat.js

@@ -53,8 +53,9 @@ function main() {
                 lastSize = currSize;
             }
         }
-        catch {
+        catch (e) {
             // file may be truncated or removed — reset so we pick up from start of new file
+            console.error(`[chat] conversation log read failed: ${e}`);
             lastSize = 0;
         }
     };
@@ -341,7 +342,8 @@ async function captureTmuxPane(tmuxName) {
         const result = await exec("tmux", ["capture-pane", "-t", tmuxName, "-p", "-S", "-100"], 5_000);
         return result.exitCode === 0 ? result.stdout : null;
     }
-    catch {
+    catch (e) {
+        console.error(`[chat] tmux capture-pane failed for ${tmuxName}: ${e}`);
         return null;
     }
 }
@@ -437,7 +439,9 @@ function appendToInput(msg) {
     try {
         appendFileSync(INPUT_FILE, msg + "\n");
     }
-    catch { }
+    catch (e) {
+        console.error(`[chat] pending-input write failed: ${e}`);
+    }
 }
 function replayLog() {
     if (!existsSync(CONVO_LOG))
@@ -449,7 +453,9 @@ function replayLog() {
             console.log(`${DIM}--- end of history ---${RESET}\n`);
         }
     }
-    catch { }
+    catch (e) {
+        console.error(`[chat] conversation log replay failed: ${e}`);
+    }
 }
 export function colorize(text) {
     // first pass: colorize tick separator lines (──── tick #N ────)

package/dist/config.d.ts

@@ -18,6 +18,8 @@ export declare function parseCliArgs(argv: string[]): {
     runTest: boolean;
     showTasks: boolean;
     showHistory: boolean;
+    showStatus: boolean;
+    showConfig: 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, 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, runInit: false, initForce: false, runTaskCli: false };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -262,6 +291,12 @@ export function parseCliArgs(argv) {
     if (argv[2] === "history") {
         return { ...defaults, showHistory: true };
     }
+    if (argv[2] === "status") {
+        return { ...defaults, showStatus: true };
+    }
+    if (argv[2] === "config") {
+        return { ...defaults, showConfig: true };
+    }
     if (argv[2] === "init") {
         const force = argv.includes("--force") || argv.includes("-f");
         return { ...defaults, runInit: true, initForce: force };
@@ -351,7 +386,7 @@ export function parseCliArgs(argv) {
                 break;
         }
     }
-    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: 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, runInit: false, initForce: false, runTaskCli: false };
 }
 export function printHelp() {
     console.log(`aoaoe - autonomous supervisor for agent-of-empires sessions
@@ -367,6 +402,8 @@ getting started:
 commands:
   init           detect tools + sessions, import history, generate config
   (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)
   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)

package/dist/console.js

@@ -91,7 +91,8 @@ export class ReasonerConsole {
             const st = statSync(INPUT_FILE);
             return st.size > 0;
         }
-        catch {
+        catch (e) {
+            console.error(`[console] pending-input size check failed: ${e}`);
             return false;
         }
     }
@@ -133,7 +134,9 @@ export class ReasonerConsole {
         try {
             appendFileSync(CONVO_LOG, line + "\n");
         }
-        catch { }
+        catch (e) {
+            console.error(`[console] conversation log write failed: ${e}`);
+        }
         // in inline mode, also print colorized output to stderr
         if (this.inlineMode) {
             process.stderr.write(colorizeConsoleLine(line) + "\n");

package/dist/context.js

@@ -78,7 +78,8 @@ export function readContextFile(filePath) {
         evictCache();
         return content;
     }
-    catch {
+    catch (e) {
+        console.error(`[context] context file read failed for ${filePath}: ${e}`);
         return "";
     }
 }
@@ -109,8 +110,9 @@ export function discoverContextFiles(dir) {
                 seenInodes.add(inodeKey);
             }
         }
-        catch {
+        catch (e) {
             // stat failed — still add by path to avoid silently dropping
+            console.error(`[context] inode de-dup stat failed for ${resolved}: ${e}`);
         }
         seenPaths.add(resolved);
         found.push(filePath);

package/dist/executor.js

@@ -164,7 +164,8 @@ export class Executor {
                 return this.logAction({ action: "create_agent", path, title, tool }, false, `path is not a directory: ${path}`);
             }
         }
-        catch {
+        catch (e) {
+            console.error(`[executor] statSync failed for create_agent path ${path}: ${e}`);
             return this.logAction({ action: "create_agent", path, title, tool }, false, `cannot stat path: ${path}`);
         }
         // validate tool name
@@ -281,7 +282,9 @@ export class Executor {
                 this.rotateLogIfNeeded();
                 appendFileSync(LOG_FILE, JSON.stringify(entry) + "\n");
             }
-            catch { } // best-effort, don't crash the daemon
+            catch (e) {
+                console.error(`[executor] action log write failed: ${e}`);
+            } // best-effort, don't crash the daemon
         }
         return entry;
     }

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { loadConfig, validateEnvironment, parseCliArgs, printHelp, configFileExists } from "./config.js";
+import { loadConfig, validateEnvironment, parseCliArgs, printHelp, configFileExists, findConfigFile } from "./config.js";
 import { Poller, computeTmuxName } from "./poller.js";
 import { createReasoner } from "./reasoner/index.js";
 import { Executor } from "./executor.js";
 import { printDashboard } from "./dashboard.js";
 import { InputReader } from "./input.js";
 import { ReasonerConsole } from "./console.js";
-import { writeState, buildSessionStates, checkInterrupt, clearInterrupt, cleanupState, acquireLock } from "./daemon-state.js";
+import { writeState, buildSessionStates, checkInterrupt, clearInterrupt, cleanupState, acquireLock, readState } from "./daemon-state.js";
 import { formatSessionSummaries, formatActionDetail, formatPlainEnglishAction, narrateObservation, summarizeRecentActions, friendlyError } from "./console.js";
 import { loadGlobalContext, resolveProjectDirWithSource, discoverContextFiles, loadSessionContext } from "./context.js";
 import { tick as loopTick } from "./loop.js";
@@ -16,6 +16,8 @@ import { classifyMessages, formatUserMessages, buildReceipts, shouldSkipSleep, h
 import { TaskManager, loadTaskDefinitions, loadTaskState, formatTaskTable } from "./task-manager.js";
 import { runTaskCli, handleTaskSlashCommand } from "./task-cli.js";
 import { TUI } from "./tui.js";
+import { isDaemonRunningFromState } from "./chat.js";
+import { sendNotification } 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";
@@ -26,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, runInit, initForce, runTaskCli: isTaskCli, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, runInit, initForce, runTaskCli: isTaskCli, registerTitle } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -66,6 +68,16 @@ async function main() {
         await showActionHistory();
         return;
     }
+    // `aoaoe status` -- quick one-shot daemon health check
+    if (showStatus) {
+        showDaemonStatus();
+        return;
+    }
+    // `aoaoe config` -- show effective resolved config
+    if (showConfig) {
+        showEffectiveConfig();
+        return;
+    }
     // `aoaoe task` -- task management CLI
     if (isTaskCli) {
         await runTaskCli(process.argv);
@@ -273,6 +285,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())
@@ -296,6 +310,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
@@ -669,6 +685,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)
@@ -739,6 +768,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;
@@ -1101,6 +1137,80 @@ async function runIntegrationTest() {
     // the integration test is a self-contained script that runs main() on import
     await import(testModule);
 }
+// `aoaoe status` -- quick one-shot health check: is the daemon running? what's it doing?
+function showDaemonStatus() {
+    const state = readState();
+    const running = isDaemonRunningFromState(state);
+    const pkg = readPkgVersion();
+    console.log("");
+    console.log(`  aoaoe${pkg ? ` v${pkg}` : ""} — daemon status`);
+    console.log(`  ${"─".repeat(50)}`);
+    if (!running || !state) {
+        console.log(`  ${RED}●${RESET} daemon is ${BOLD}not running${RESET}`);
+        const configPath = findConfigFile();
+        console.log(`  config: ${configPath ?? "none found (run 'aoaoe init')"}`);
+        console.log("");
+        console.log("  start with: aoaoe");
+        console.log("  or observe: aoaoe --observe");
+        console.log("");
+        return;
+    }
+    // daemon is running — show details
+    const elapsed = Date.now() - state.phaseStartedAt;
+    const elapsedStr = elapsed < 60_000 ? `${Math.floor(elapsed / 1000)}s` : `${Math.floor(elapsed / 60_000)}m`;
+    const phaseIcon = state.phase === "sleeping" ? `${DIM}○${RESET}` :
+        state.phase === "reasoning" ? `${YELLOW}●${RESET}` :
+            state.phase === "executing" ? `${GREEN}●${RESET}` :
+                state.phase === "polling" ? `${YELLOW}○${RESET}` :
+                    `${RED}●${RESET}`;
+    console.log(`  ${GREEN}●${RESET} daemon is ${BOLD}running${RESET}  (poll #${state.pollCount})`);
+    console.log(`  ${phaseIcon} phase: ${state.phase} (${elapsedStr})`);
+    if (state.paused)
+        console.log(`  ${YELLOW}${BOLD}  PAUSED${RESET}`);
+    console.log(`  poll interval: ${state.pollIntervalMs / 1000}s`);
+    if (state.nextTickAt > Date.now()) {
+        const countdown = Math.ceil((state.nextTickAt - Date.now()) / 1000);
+        console.log(`  next tick: ${countdown}s`);
+    }
+    console.log("");
+    // sessions
+    if (state.sessions.length === 0) {
+        console.log("  no active sessions");
+    }
+    else {
+        console.log(`  ${state.sessions.length} session(s):`);
+        for (const s of state.sessions) {
+            const statusIcon = s.status === "working" || s.status === "running" ? `${GREEN}●${RESET}` :
+                s.status === "idle" ? `${DIM}○${RESET}` :
+                    s.status === "error" ? `${RED}●${RESET}` :
+                        s.status === "done" ? `${GREEN}✓${RESET}` :
+                            `${DIM}?${RESET}`;
+            const userTag = s.userActive ? ` ${DIM}(user active)${RESET}` : "";
+            const taskTag = s.currentTask ? ` — ${DIM}${s.currentTask.slice(0, 50)}${RESET}` : "";
+            console.log(`    ${statusIcon} ${BOLD}${s.title}${RESET} (${s.tool}) ${s.status}${userTag}${taskTag}`);
+        }
+    }
+    console.log("");
+}
+// `aoaoe config` -- show the effective resolved config (defaults + file + any notes)
+function showEffectiveConfig() {
+    const configPath = findConfigFile();
+    const configResult = loadConfig();
+    // strip _configPath from output
+    const { _configPath, ...config } = configResult;
+    console.log("");
+    console.log("  aoaoe — effective config");
+    console.log(`  ${"─".repeat(50)}`);
+    console.log(`  source: ${configPath ?? "defaults (no config file found)"}`);
+    console.log("");
+    console.log(JSON.stringify(config, null, 2));
+    console.log("");
+    // helpful notes
+    if (!configPath) {
+        console.log(`  ${DIM}create a config: aoaoe init${RESET}`);
+        console.log("");
+    }
+}
 main().catch((err) => {
     console.error(`fatal: ${err}`);
     process.exit(1);

package/dist/init.js

@@ -60,7 +60,8 @@ async function discoverSessions() {
             .filter((r) => r.status === "fulfilled")
             .map((r) => r.value);
     }
-    catch {
+    catch (e) {
+        console.error(`[init] failed to parse session list: ${e}`);
         return [];
     }
 }
@@ -72,7 +73,8 @@ async function getSessionStatus(id) {
         const data = JSON.parse(result.stdout);
         return toSessionStatus(data.status);
     }
-    catch {
+    catch (e) {
+        console.error(`[init] failed to parse session status for ${id}: ${e}`);
         return "unknown";
     }
 }

package/dist/notify.d.ts

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

package/dist/notify.js

@@ -0,0 +1,104 @@
+// send a notification to all configured webhooks.
+// fire-and-forget: never throws, never blocks the daemon.
+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;
+    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);
+}
+// 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/poller.js

@@ -115,7 +115,8 @@ export class Poller {
             const data = JSON.parse(result.stdout);
             return toSessionStatus(data.status);
         }
-        catch {
+        catch (e) {
+            console.error(`[poller] failed to parse session status for ${id}: ${e}`);
             return "unknown";
         }
     }
@@ -232,7 +233,8 @@ export async function listAoeSessionsShared(timeoutMs = 10_000) {
         const parsed = JSON.parse(result.stdout);
         raw = Array.isArray(parsed) ? parsed : [];
     }
-    catch {
+    catch (e) {
+        console.error(`[poller] failed to parse session list: ${e}`);
         return [];
     }
     const results = await Promise.allSettled(raw.map(async (s) => {
@@ -245,7 +247,9 @@ export async function listAoeSessionsShared(timeoutMs = 10_000) {
                 status = JSON.parse(showResult.stdout).status ?? "unknown";
             }
         }
-        catch { }
+        catch (e) {
+            console.error(`[poller] failed to parse session show for ${id}: ${e}`);
+        }
         return { id, title, tool: s.tool ?? "", status, tmuxName: computeTmuxName(id, title) };
     }));
     return results

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