aoaoe 0.67.0 → 0.69.0

package/dist/config-watcher.d.ts

@@ -0,0 +1,44 @@
+import type { AoaoeConfig } from "./types.js";
+/** Describes a single config field change */
+export interface ConfigChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    applied: boolean;
+}
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export declare function mergeHotReload(current: AoaoeConfig, fresh: AoaoeConfig): {
+    config: AoaoeConfig;
+    changes: ConfigChange[];
+};
+/**
+ * Format a config change for display in the TUI.
+ */
+export declare function formatConfigChange(change: ConfigChange): string;
+export type ConfigChangeCallback = (changes: ConfigChange[], newConfig: AoaoeConfig) => void;
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export declare class ConfigWatcher {
+    private watcher;
+    private debounceTimer;
+    private configPath;
+    private callback;
+    private currentConfig;
+    private debounceMs;
+    constructor(config: AoaoeConfig, debounceMs?: number);
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback: ConfigChangeCallback): string | null;
+    /** Stop watching */
+    stop(): void;
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig(): AoaoeConfig;
+    private scheduleReload;
+    private doReload;
+}
+//# sourceMappingURL=config-watcher.d.ts.map

package/dist/config-watcher.js

@@ -0,0 +1,159 @@
+// config-watcher.ts — watch config file for changes and hot-reload safe fields.
+// pure mergeHotReload function + ConfigWatcher class using fs.watch.
+import { watch } from "node:fs";
+import { loadConfig, findConfigFile, validateConfig } from "./config.js";
+/**
+ * Fields that are safe to hot-reload without restarting the daemon.
+ * Fields NOT in this list require a daemon restart to take effect.
+ *
+ * Unsafe (require restart): reasoner, opencode.port, healthPort, dryRun, observe, confirm
+ */
+const HOT_RELOAD_FIELDS = new Set([
+    "pollIntervalMs",
+    "sessionDirs",
+    "protectedSessions",
+    "contextFiles",
+    "verbose",
+    "captureLinesCount",
+    "tuiHistoryRetentionDays",
+]);
+/** Nested objects where all sub-fields are safe to hot-reload */
+const HOT_RELOAD_OBJECTS = new Set([
+    "policies",
+    "notifications",
+]);
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export function mergeHotReload(current, fresh) {
+    const changes = [];
+    const merged = { ...current };
+    // check top-level scalar/array fields
+    for (const field of HOT_RELOAD_FIELDS) {
+        const key = field;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // check nested objects (policies, notifications)
+    for (const objField of HOT_RELOAD_OBJECTS) {
+        const key = objField;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: objField, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // detect non-reloadable changes (warn user)
+    const unsafeFields = [
+        "reasoner", "dryRun", "observe", "confirm", "healthPort",
+    ];
+    for (const key of unsafeFields) {
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: key, oldValue: current[key], newValue: fresh[key], applied: false });
+        }
+    }
+    // check nested non-reloadable (opencode.port)
+    if (current.opencode?.port !== fresh.opencode?.port) {
+        changes.push({ field: "opencode.port", oldValue: current.opencode?.port, newValue: fresh.opencode?.port, applied: false });
+    }
+    return { config: merged, changes };
+}
+/**
+ * Format a config change for display in the TUI.
+ */
+export function formatConfigChange(change) {
+    const status = change.applied ? "applied" : "requires restart";
+    const newVal = typeof change.newValue === "object"
+        ? JSON.stringify(change.newValue)
+        : String(change.newValue);
+    const truncated = newVal.length > 60 ? newVal.slice(0, 57) + "..." : newVal;
+    return `${change.field}: ${truncated} (${status})`;
+}
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export class ConfigWatcher {
+    watcher = null;
+    debounceTimer = null;
+    configPath = null;
+    callback = null;
+    currentConfig;
+    debounceMs;
+    constructor(config, debounceMs = 500) {
+        this.currentConfig = config;
+        this.debounceMs = debounceMs;
+    }
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback) {
+        this.callback = callback;
+        this.configPath = findConfigFile();
+        if (!this.configPath)
+            return null;
+        try {
+            this.watcher = watch(this.configPath, { persistent: false }, () => {
+                this.scheduleReload();
+            });
+            this.watcher.on("error", () => {
+                // config file may be renamed during save — try to re-watch
+                this.stop();
+            });
+        }
+        catch {
+            // watch failed — degrade gracefully
+            return null;
+        }
+        return this.configPath;
+    }
+    /** Stop watching */
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch { }
+            this.watcher = null;
+        }
+    }
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig() {
+        return this.currentConfig;
+    }
+    scheduleReload() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.doReload();
+        }, this.debounceMs);
+    }
+    doReload() {
+        try {
+            const fresh = loadConfig();
+            validateConfig(fresh);
+            const { config, changes } = mergeHotReload(this.currentConfig, fresh);
+            if (changes.length > 0) {
+                this.currentConfig = config;
+                this.callback?.(changes, config);
+            }
+        }
+        catch (err) {
+            // invalid config — ignore silently (keep running with current config)
+            console.error(`[config-watcher] reload failed: ${err}`);
+        }
+    }
+}
+//# sourceMappingURL=config-watcher.js.map

package/dist/config.d.ts

@@ -41,6 +41,9 @@ export declare function parseCliArgs(argv: string[]): {
     runInit: boolean;
     initForce: boolean;
     runTaskCli: boolean;
+    runTail: boolean;
+    tailFollow: boolean;
+    tailCount?: number;
     registerTitle?: string;
 };
 export declare function printHelp(): void;

package/dist/config.js

@@ -327,7 +327,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, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, 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, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -395,6 +395,21 @@ export function parseCliArgs(argv) {
         const force = argv.includes("--force") || argv.includes("-f");
         return { ...defaults, runInit: true, initForce: force };
     }
+    if (argv[2] === "tail") {
+        let follow = false;
+        let count;
+        for (let i = 3; i < argv.length; i++) {
+            if (argv[i] === "-f" || argv[i] === "--follow") {
+                follow = true;
+            }
+            else if ((argv[i] === "-n" || argv[i] === "--count") && argv[i + 1]) {
+                const val = parseInt(argv[++i], 10);
+                if (!isNaN(val) && val > 0)
+                    count = val;
+            }
+        }
+        return { ...defaults, runTail: true, tailFollow: follow, tailCount: count };
+    }
     if (argv[2] === "register") {
         register = true;
         // parse --title from remaining args
@@ -488,7 +503,7 @@ export function parseCliArgs(argv) {
                 break;
         }
     }
-    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false };
+    return { overrides, help, version, register: false, testContext: false, runTest: false, showTasks: false, showHistory: false, showStatus: false, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined };
 }
 export function printHelp() {
     console.log(`aoaoe - autonomous supervisor for agent-of-empires sessions
@@ -518,6 +533,9 @@ commands:
   export --format <json|markdown>  output format (default: json)
   export --output <file>           write to file (default: stdout)
   export --last <duration>         time window: 1h, 6h, 24h, 7d (default: 24h)
+  tail           live-stream daemon activity to a separate terminal
+  tail -f        follow mode — keep watching for new entries (Ctrl+C to stop)
+  tail -n <N>    number of entries to show (default: 50)
   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)
@@ -550,6 +568,10 @@ logs options:
   --grep, -g <pattern>               filter entries by substring or regex
   -n, --count <number>               number of entries to show (default: 50)
 
+tail options:
+  -f, --follow                       keep watching for new entries (Ctrl+C to stop)
+  -n, --count <number>               number of entries to show (default: 50)
+
 register options:
   --title, -t <name>                 session title in AoE (default: aoaoe)
 

package/dist/executor.d.ts

@@ -10,6 +10,8 @@ export declare class Executor {
     private taskManager?;
     constructor(config: AoaoeConfig);
     setTaskManager(tm: TaskManager): void;
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig: AoaoeConfig): void;
     execute(actions: Action[], snapshots: SessionSnapshot[]): Promise<ActionLogEntry[]>;
     private executeOne;
     private sendInput;

package/dist/executor.js

@@ -32,6 +32,10 @@ export class Executor {
     setTaskManager(tm) {
         this.taskManager = tm;
     }
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig) {
+        this.config = newConfig;
+    }
     async execute(actions, snapshots) {
         const results = [];
         for (const action of actions) {

package/dist/index.js

@@ -20,6 +20,7 @@ import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
 import { loadTuiHistory } from "./tui-history.js";
+import { ConfigWatcher, formatConfigChange } from "./config-watcher.js";
 import { parseActionLogEntries, parseActivityEntries, mergeTimeline, filterByAge, parseDuration, formatTimelineJson, formatTimelineMarkdown } from "./export.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
@@ -31,7 +32,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, configValidate, configDiff, notifyTest, runDoctor, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showHistory, showStatus, showConfig, configValidate, configDiff, notifyTest, runDoctor, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, registerTitle } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -120,6 +121,12 @@ async function main() {
         await doInit(initForce);
         return;
     }
+    // `aoaoe tail` -- live-stream daemon activity to a separate terminal
+    if (isTail) {
+        const { runTail: doTail } = await import("./tail.js");
+        await doTail({ count: tailCount ?? 50, follow: tailFollow });
+        return;
+    }
     // auto-init: if no config file exists, run init automatically
     if (!configFileExists()) {
         console.error("");
@@ -137,7 +144,7 @@ async function main() {
     }
     const configResult = loadConfig(overrides);
     const configPath = configResult._configPath;
-    const config = configResult; // strip _configPath from type for downstream
+    let config = configResult; // strip _configPath from type for downstream (let: hot-reloaded)
     // acquire daemon lock — prevent two daemons from running simultaneously
     const lock = acquireLock();
     if (!lock.acquired) {
@@ -373,6 +380,7 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        configWatcher.stop();
         if (healthServer)
             healthServer.close();
         // notify: daemon stopped (fire-and-forget, don't block shutdown)
@@ -400,6 +408,36 @@ async function main() {
     else {
         log("entering main loop (Ctrl+C to stop)\n");
     }
+    // ── config hot-reload watcher ──────────────────────────────────────────────
+    const configWatcher = new ConfigWatcher(config);
+    const watchedPath = configWatcher.start((changes, newConfig) => {
+        config = newConfig;
+        if (executor)
+            executor.updateConfig(newConfig);
+        const applied = changes.filter((c) => c.applied);
+        const needsRestart = changes.filter((c) => !c.applied);
+        for (const c of applied) {
+            const msg = `config: ${formatConfigChange(c)}`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+        for (const c of needsRestart) {
+            const msg = `config: ${c.field} changed but requires restart`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+    });
+    if (watchedPath) {
+        const msg = `watching config: ${watchedPath}`;
+        if (tui)
+            tui.log("system", msg);
+        else
+            log(msg);
+    }
     // notify: daemon started
     sendNotification(config, { event: "daemon_started", timestamp: Date.now(), detail: `reasoner: ${config.reasoner}` });
     // clear any stale interrupt from a previous run

package/dist/tail.d.ts

@@ -0,0 +1,41 @@
+import { type HistoryEntry } from "./tui-history.js";
+/**
+ * Format a HistoryEntry as a colorized terminal line.
+ * Matches TUI formatActivity style but for plain scrolling output.
+ */
+export declare function formatTailEntry(entry: HistoryEntry): string;
+/**
+ * Format a date string for the tail header.
+ */
+export declare function formatTailDate(ts: number): string;
+/**
+ * Load the last N entries from the history file.
+ * Returns entries newest-last (chronological order).
+ */
+export declare function loadTailEntries(count: number, filePath?: string): HistoryEntry[];
+/**
+ * Get the current file size (for follow mode to detect appends).
+ */
+export declare function getFileSize(filePath: string): number;
+/**
+ * Read new bytes appended since a given offset, parse into entries.
+ */
+export declare function readNewEntries(filePath: string, fromByte: number): {
+    entries: HistoryEntry[];
+    newSize: number;
+};
+/**
+ * Print entries to stderr (colorized).
+ */
+export declare function printEntries(entries: HistoryEntry[]): void;
+/**
+ * Run the tail command.
+ * Without follow: print last N entries, exit.
+ * With follow: print last N, then watch for new entries (blocks until Ctrl+C).
+ */
+export declare function runTail(opts: {
+    count: number;
+    follow: boolean;
+    filePath?: string;
+}): Promise<void>;
+//# sourceMappingURL=tail.d.ts.map

package/dist/tail.js

@@ -0,0 +1,211 @@
+// tail.ts — live-stream daemon activity to a separate terminal.
+// reads from tui-history.jsonl, optionally follows for new entries.
+// pure exported functions for testability.
+import { readFileSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { watch } from "node:fs";
+import { TUI_HISTORY_FILE } from "./tui-history.js";
+import { SLATE, RESET, DIM, BOLD, CYAN, AMBER, ROSE, LIME, SKY, } from "./colors.js";
+/**
+ * Format a HistoryEntry as a colorized terminal line.
+ * Matches TUI formatActivity style but for plain scrolling output.
+ */
+export function formatTailEntry(entry) {
+    let color = SLATE;
+    let prefix = entry.tag;
+    switch (entry.tag) {
+        case "observation":
+            color = SLATE;
+            prefix = "obs";
+            break;
+        case "reasoner":
+            color = SKY;
+            break;
+        case "explain":
+            color = `${BOLD}${CYAN}`;
+            prefix = "AI";
+            break;
+        case "+ action":
+        case "action":
+            color = AMBER;
+            prefix = "→ action";
+            break;
+        case "! action":
+        case "error":
+            color = ROSE;
+            prefix = "✗ error";
+            break;
+        case "you":
+            color = LIME;
+            break;
+        case "system":
+            color = SLATE;
+            break;
+        case "status":
+            color = SLATE;
+            break;
+        default:
+            color = SLATE;
+            break;
+    }
+    return `${SLATE}${entry.time}${RESET} ${color}${prefix}${RESET} ${DIM}│${RESET} ${entry.text}`;
+}
+/**
+ * Format a date string for the tail header.
+ */
+export function formatTailDate(ts) {
+    const d = new Date(ts);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+/**
+ * Load the last N entries from the history file.
+ * Returns entries newest-last (chronological order).
+ */
+export function loadTailEntries(count, filePath = TUI_HISTORY_FILE) {
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        const entries = [];
+        // read from the end to minimize parsing
+        const start = Math.max(0, lines.length - count);
+        for (let i = start; i < lines.length; i++) {
+            try {
+                const parsed = JSON.parse(lines[i]);
+                if (isValidEntry(parsed))
+                    entries.push(parsed);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the current file size (for follow mode to detect appends).
+ */
+export function getFileSize(filePath) {
+    try {
+        return statSync(filePath).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Read new bytes appended since a given offset, parse into entries.
+ */
+export function readNewEntries(filePath, fromByte) {
+    try {
+        const size = statSync(filePath).size;
+        if (size === 0)
+            return { entries: [], newSize: 0 };
+        // file was truncated/rotated — read from start
+        const start = size < fromByte ? 0 : fromByte;
+        if (start === size)
+            return { entries: [], newSize: size };
+        const buf = Buffer.alloc(size - start);
+        const fd = openSync(filePath, "r");
+        readSync(fd, buf, 0, buf.length, start);
+        closeSync(fd);
+        const text = buf.toString("utf-8");
+        const lines = text.split("\n").filter((l) => l.trim());
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isValidEntry(parsed))
+                    entries.push(parsed);
+            }
+            catch {
+                // skip
+            }
+        }
+        return { entries, newSize: size };
+    }
+    catch {
+        return { entries: [], newSize: fromByte };
+    }
+}
+/**
+ * Print entries to stderr (colorized).
+ */
+export function printEntries(entries) {
+    for (const e of entries) {
+        process.stderr.write(formatTailEntry(e) + "\n");
+    }
+}
+/**
+ * Run the tail command.
+ * Without follow: print last N entries, exit.
+ * With follow: print last N, then watch for new entries (blocks until Ctrl+C).
+ */
+export async function runTail(opts) {
+    const filePath = opts.filePath ?? TUI_HISTORY_FILE;
+    // print initial entries
+    const entries = loadTailEntries(opts.count, filePath);
+    if (entries.length === 0) {
+        process.stderr.write(`${DIM}no history entries found${RESET}\n`);
+        if (!opts.follow)
+            return;
+        process.stderr.write(`${DIM}waiting for new entries... (Ctrl+C to stop)${RESET}\n`);
+    }
+    else {
+        // date header
+        const firstDate = formatTailDate(entries[0].ts);
+        const lastDate = formatTailDate(entries[entries.length - 1].ts);
+        const dateRange = firstDate === lastDate ? firstDate : `${firstDate} → ${lastDate}`;
+        process.stderr.write(`${DIM}── ${entries.length} entries (${dateRange}) ──${RESET}\n`);
+        printEntries(entries);
+    }
+    if (!opts.follow)
+        return;
+    // follow mode: watch file for changes
+    process.stderr.write(`${DIM}── following (Ctrl+C to stop) ──${RESET}\n`);
+    let lastSize = getFileSize(filePath);
+    return new Promise((_resolve) => {
+        let watcher = null;
+        try {
+            watcher = watch(filePath, { persistent: true }, () => {
+                const { entries: newEntries, newSize } = readNewEntries(filePath, lastSize);
+                if (newEntries.length > 0) {
+                    printEntries(newEntries);
+                }
+                lastSize = newSize;
+            });
+            watcher.on("error", () => {
+                // file may be rotated — try to recover
+                lastSize = 0;
+            });
+        }
+        catch {
+            process.stderr.write(`${ROSE}failed to watch ${filePath}${RESET}\n`);
+        }
+        // Ctrl+C cleanup
+        const cleanup = () => {
+            if (watcher) {
+                try {
+                    watcher.close();
+                }
+                catch { }
+            }
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    });
+}
+function isValidEntry(val) {
+    if (typeof val !== "object" || val === null)
+        return false;
+    const obj = val;
+    return (typeof obj.ts === "number" &&
+        typeof obj.time === "string" &&
+        typeof obj.tag === "string" &&
+        typeof obj.text === "string");
+}
+//# sourceMappingURL=tail.js.map

package/package.json

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