aoaoe 1.0.0 → 2.0.0

package/README.md

@@ -4,7 +4,7 @@
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml"><img src="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
     <a href="https://www.npmjs.com/package/aoaoe"><img src="https://img.shields.io/npm/v/aoaoe" alt="npm version"></a>
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/releases"><img src="https://img.shields.io/github/v/release/Talador12/agent-of-agent-of-empires" alt="GitHub release"></a>
-    <img src="https://img.shields.io/badge/tests-2427-brightgreen" alt="tests">
+    <img src="https://img.shields.io/badge/tests-3332-brightgreen" alt="tests">
     <img src="https://img.shields.io/badge/node-%3E%3D20-blue" alt="Node.js >= 20">
     <img src="https://img.shields.io/badge/runtime%20deps-0-brightgreen" alt="zero runtime dependencies">
     <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
@@ -822,6 +822,28 @@ The daemon and chat UI communicate via files in `~/.aoaoe/`:
 | `chat.pid` | chat UI | daemon | Chat process PID for detection |
 | `actions.log` | daemon | -- | Persistent action history (JSONL) |
 
+## Intelligence Modules
+
+aoaoe includes 55 intelligence modules that run every daemon tick without LLM calls. They handle observability, automation, and fleet management autonomously:
+
+**Reasoning Pipeline** (7 gates, runs before every LLM call):
+- Fleet rate limiter, observation cache, priority filter, context compressor, LLM call, approval workflow, cost tracker
+
+**Per-Tick Autonomous Systems**:
+- Session summarizer, conflict detector + auto-resolver, goal completion detector, cost budget enforcer
+- Activity heatmap, budget predictor, task retry with backoff, adaptive poll controller
+- Fleet SLA monitor, progress velocity tracker, recovery playbook, dependency scheduler
+- Session graduation (trust ladder), fleet utilization tracker, anomaly detector
+- Workflow engine (fan-out/fan-in stage orchestration)
+
+**On-Demand Analytics** (via TUI commands):
+- Audit trail + search, fleet snapshots + diff, lifecycle analytics, cost attribution
+- Goal decomposition, difficulty scoring, smart nudge generation, template auto-detection
+- Fleet-wide search, nudge effectiveness tracking, difficulty-based allocation
+- Goal refinement from completed task patterns, fleet HTML export, session replay
+
+See `AGENTS.md` for the full source layout with all 55 modules described.
+
 ## Project Structure
 
 ```

package/dist/ab-reasoning.d.ts

@@ -0,0 +1,42 @@
+import type { ReasonerResult, Action } from "./types.js";
+export interface ABTrialResult {
+    timestamp: number;
+    backendA: string;
+    backendB: string;
+    actionsA: Action[];
+    actionsB: Action[];
+    confidenceA?: string;
+    confidenceB?: string;
+    winner: "a" | "b" | "tie";
+    reason: string;
+}
+export interface ABStats {
+    totalTrials: number;
+    winsA: number;
+    winsB: number;
+    ties: number;
+    backendA: string;
+    backendB: string;
+}
+/**
+ * Compare two reasoner results and determine which is better.
+ * Heuristic: more specific actions > wait, higher confidence > lower,
+ * fewer redundant actions = better.
+ */
+export declare function compareResults(resultA: ReasonerResult, resultB: ReasonerResult, backendA: string, backendB: string, now?: number): ABTrialResult;
+/**
+ * Track A/B trial results over time.
+ */
+export declare class ABReasoningTracker {
+    private trials;
+    private backendA;
+    private backendB;
+    constructor(backendA: string, backendB: string);
+    /** Record a trial result. */
+    recordTrial(result: ABTrialResult): void;
+    /** Get aggregate stats. */
+    getStats(): ABStats;
+    /** Format stats for TUI display. */
+    formatStats(): string[];
+}
+//# sourceMappingURL=ab-reasoning.d.ts.map

package/dist/ab-reasoning.js

@@ -0,0 +1,91 @@
+// ab-reasoning.ts — run two reasoner backends on the same observation,
+// compare their outputs, and track which performs better over time.
+/**
+ * Compare two reasoner results and determine which is better.
+ * Heuristic: more specific actions > wait, higher confidence > lower,
+ * fewer redundant actions = better.
+ */
+export function compareResults(resultA, resultB, backendA, backendB, now = Date.now()) {
+    let scoreA = 0;
+    let scoreB = 0;
+    // prefer non-wait actions over wait
+    const nonWaitA = resultA.actions.filter((a) => a.action !== "wait").length;
+    const nonWaitB = resultB.actions.filter((a) => a.action !== "wait").length;
+    if (nonWaitA > nonWaitB)
+        scoreA += 2;
+    else if (nonWaitB > nonWaitA)
+        scoreB += 2;
+    // prefer higher confidence
+    const confOrder = { high: 3, medium: 2, low: 1 };
+    const confA = confOrder[resultA.confidence ?? "medium"] ?? 2;
+    const confB = confOrder[resultB.confidence ?? "medium"] ?? 2;
+    if (confA > confB)
+        scoreA += 1;
+    else if (confB > confA)
+        scoreB += 1;
+    // prefer fewer total actions (more focused)
+    if (resultA.actions.length > 0 && resultB.actions.length > 0) {
+        if (resultA.actions.length < resultB.actions.length)
+            scoreA += 1;
+        else if (resultB.actions.length < resultA.actions.length)
+            scoreB += 1;
+    }
+    const winner = scoreA > scoreB ? "a" : scoreB > scoreA ? "b" : "tie";
+    const reason = `A(${nonWaitA} actions, ${resultA.confidence ?? "?"}) vs B(${nonWaitB} actions, ${resultB.confidence ?? "?"})`;
+    return {
+        timestamp: now,
+        backendA,
+        backendB,
+        actionsA: resultA.actions,
+        actionsB: resultB.actions,
+        confidenceA: resultA.confidence,
+        confidenceB: resultB.confidence,
+        winner,
+        reason,
+    };
+}
+/**
+ * Track A/B trial results over time.
+ */
+export class ABReasoningTracker {
+    trials = [];
+    backendA;
+    backendB;
+    constructor(backendA, backendB) {
+        this.backendA = backendA;
+        this.backendB = backendB;
+    }
+    /** Record a trial result. */
+    recordTrial(result) {
+        this.trials.push(result);
+    }
+    /** Get aggregate stats. */
+    getStats() {
+        return {
+            totalTrials: this.trials.length,
+            winsA: this.trials.filter((t) => t.winner === "a").length,
+            winsB: this.trials.filter((t) => t.winner === "b").length,
+            ties: this.trials.filter((t) => t.winner === "tie").length,
+            backendA: this.backendA,
+            backendB: this.backendB,
+        };
+    }
+    /** Format stats for TUI display. */
+    formatStats() {
+        const s = this.getStats();
+        if (s.totalTrials === 0)
+            return ["  (no A/B trials recorded yet)"];
+        const pctA = s.totalTrials > 0 ? Math.round((s.winsA / s.totalTrials) * 100) : 0;
+        const pctB = s.totalTrials > 0 ? Math.round((s.winsB / s.totalTrials) * 100) : 0;
+        return [
+            `  A/B Reasoning: ${s.totalTrials} trials`,
+            `  ${s.backendA}: ${s.winsA} wins (${pctA}%)`,
+            `  ${s.backendB}: ${s.winsB} wins (${pctB}%)`,
+            `  Ties: ${s.ties}`,
+            s.winsA > s.winsB ? `  → ${s.backendA} is performing better` :
+                s.winsB > s.winsA ? `  → ${s.backendB} is performing better` :
+                    `  → Both backends performing equally`,
+        ];
+    }
+}
+//# sourceMappingURL=ab-reasoning.js.map

package/dist/alert-rules.d.ts

@@ -0,0 +1,42 @@
+export type AlertSeverity = "info" | "warning" | "critical";
+export type AlertCondition = (ctx: AlertContext) => boolean;
+export interface AlertContext {
+    fleetHealth: number;
+    activeSessions: number;
+    errorSessions: number;
+    totalCostUsd: number;
+    hourlyCostRate: number;
+    stuckSessions: number;
+    idleMinutes: Map<string, number>;
+}
+export interface AlertRule {
+    name: string;
+    description: string;
+    severity: AlertSeverity;
+    condition: AlertCondition;
+    cooldownMs: number;
+    lastFiredAt: number;
+}
+export interface FiredAlert {
+    ruleName: string;
+    severity: AlertSeverity;
+    message: string;
+    timestamp: number;
+}
+/**
+ * Built-in alert rules.
+ */
+export declare function defaultAlertRules(): AlertRule[];
+/**
+ * Evaluate all alert rules against current fleet state.
+ */
+export declare function evaluateAlertRules(rules: AlertRule[], ctx: AlertContext, now?: number): FiredAlert[];
+/**
+ * Format fired alerts for TUI display.
+ */
+export declare function formatFiredAlerts(alerts: FiredAlert[]): string[];
+/**
+ * Format all rules and their status for TUI display.
+ */
+export declare function formatAlertRules(rules: AlertRule[], now?: number): string[];
+//# sourceMappingURL=alert-rules.d.ts.map

package/dist/alert-rules.js

@@ -0,0 +1,94 @@
+// alert-rules.ts — custom fleet health alerting rules beyond SLA threshold.
+// define conditions that trigger alerts when met, with configurable
+// severity, cooldown, and notification routing.
+/**
+ * Built-in alert rules.
+ */
+export function defaultAlertRules() {
+    return [
+        {
+            name: "fleet-health-critical",
+            description: "Fleet health dropped below 30",
+            severity: "critical",
+            condition: (ctx) => ctx.fleetHealth < 30,
+            cooldownMs: 10 * 60_000,
+            lastFiredAt: 0,
+        },
+        {
+            name: "high-error-rate",
+            description: "More than 50% of sessions in error state",
+            severity: "critical",
+            condition: (ctx) => ctx.activeSessions > 0 && (ctx.errorSessions / ctx.activeSessions) > 0.5,
+            cooldownMs: 5 * 60_000,
+            lastFiredAt: 0,
+        },
+        {
+            name: "cost-spike",
+            description: "Hourly cost rate exceeds $5",
+            severity: "warning",
+            condition: (ctx) => ctx.hourlyCostRate > 5,
+            cooldownMs: 15 * 60_000,
+            lastFiredAt: 0,
+        },
+        {
+            name: "all-stuck",
+            description: "All active sessions are stuck",
+            severity: "critical",
+            condition: (ctx) => ctx.activeSessions > 0 && ctx.stuckSessions === ctx.activeSessions,
+            cooldownMs: 10 * 60_000,
+            lastFiredAt: 0,
+        },
+        {
+            name: "no-active-sessions",
+            description: "No active sessions running",
+            severity: "info",
+            condition: (ctx) => ctx.activeSessions === 0,
+            cooldownMs: 30 * 60_000,
+            lastFiredAt: 0,
+        },
+    ];
+}
+/**
+ * Evaluate all alert rules against current fleet state.
+ */
+export function evaluateAlertRules(rules, ctx, now = Date.now()) {
+    const fired = [];
+    for (const rule of rules) {
+        if (now - rule.lastFiredAt < rule.cooldownMs)
+            continue;
+        if (rule.condition(ctx)) {
+            rule.lastFiredAt = now;
+            fired.push({
+                ruleName: rule.name,
+                severity: rule.severity,
+                message: rule.description,
+                timestamp: now,
+            });
+        }
+    }
+    return fired;
+}
+/**
+ * Format fired alerts for TUI display.
+ */
+export function formatFiredAlerts(alerts) {
+    if (alerts.length === 0)
+        return ["  ✅ no alerts fired"];
+    const icons = { info: "ℹ", warning: "⚠", critical: "🚨" };
+    return alerts.map((a) => `  ${icons[a.severity]} [${a.severity}] ${a.ruleName}: ${a.message}`);
+}
+/**
+ * Format all rules and their status for TUI display.
+ */
+export function formatAlertRules(rules, now = Date.now()) {
+    const lines = [];
+    lines.push(`  Alert rules (${rules.length}):`);
+    for (const r of rules) {
+        const cooldownRemaining = Math.max(0, r.cooldownMs - (now - r.lastFiredAt));
+        const cooldownStr = cooldownRemaining > 0 ? ` (cooldown: ${Math.round(cooldownRemaining / 60_000)}m)` : "";
+        const icon = r.severity === "critical" ? "🚨" : r.severity === "warning" ? "⚠" : "ℹ";
+        lines.push(`  ${icon} ${r.name}: ${r.description}${cooldownStr}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=alert-rules.js.map

package/dist/cli-completions.d.ts

@@ -0,0 +1,24 @@
+export declare const CLI_COMMANDS: readonly ["init", "tasks", "progress", "health", "summary", "supervisor", "incident", "runbook", "adopt", "doctor", "stats", "replay", "export", "tail", "web", "sync", "test-context", "task", "config"];
+export declare const CLI_FLAGS: readonly ["--config", "--verbose", "--dry-run", "--observe", "--confirm", "--json", "--ndjson", "--watch", "--changes-only", "--heartbeat", "--follow", "--help", "--version"];
+export declare const TUI_COMMANDS: readonly ["/supervisor", "/incident", "/runbook", "/progress", "/health", "/prompt-template", "/pin-save", "/pin-load", "/pin-presets", "/activity", "/conflicts", "/heatmap", "/audit", "/audit-stats", "/audit-search", "/fleet-snap", "/budget-predict", "/retries", "/fleet-forecast", "/priority", "/escalations", "/poll-status", "/drift", "/goal-progress", "/pool", "/reasoner-cost", "/anomaly", "/sla", "/velocity", "/schedule", "/cost-summary", "/session-report", "/cache", "/rate-limit", "/recovery", "/lifecycle", "/cost-report", "/decompose", "/memory", "/dep-graph", "/approvals", "/approve", "/reject", "/fleet-diff", "/template", "/difficulty", "/smart-nudge", "/utilization", "/detect-template", "/fleet-search", "/nudge-stats", "/allocation", "/graduation", "/refine", "/export", "/clear"];
+/**
+ * Generate bash completion script.
+ */
+export declare function generateBashCompletion(): string;
+/**
+ * Generate zsh completion script.
+ */
+export declare function generateZshCompletion(): string;
+/**
+ * Generate fish completion script.
+ */
+export declare function generateFishCompletion(): string;
+/**
+ * Generate completion script for the specified shell.
+ */
+export declare function generateCompletion(shell: "bash" | "zsh" | "fish"): string;
+/**
+ * List all available commands for help display.
+ */
+export declare function formatCommandList(): string[];
+//# sourceMappingURL=cli-completions.d.ts.map

package/dist/cli-completions.js

@@ -0,0 +1,114 @@
+// cli-completions.ts — shell autocomplete for all aoaoe commands and TUI slash commands.
+// generates completion scripts for bash, zsh, and fish.
+export const CLI_COMMANDS = [
+    "init", "tasks", "progress", "health", "summary", "supervisor",
+    "incident", "runbook", "adopt", "doctor", "stats", "replay",
+    "export", "tail", "web", "sync", "test-context",
+    "task", "config",
+];
+export const CLI_FLAGS = [
+    "--config", "--verbose", "--dry-run", "--observe", "--confirm",
+    "--json", "--ndjson", "--watch", "--changes-only", "--heartbeat", "--follow",
+    "--help", "--version",
+];
+export const TUI_COMMANDS = [
+    "/supervisor", "/incident", "/runbook", "/progress", "/health",
+    "/prompt-template", "/pin-save", "/pin-load", "/pin-presets",
+    "/activity", "/conflicts", "/heatmap", "/audit", "/audit-stats",
+    "/audit-search", "/fleet-snap", "/budget-predict", "/retries",
+    "/fleet-forecast", "/priority", "/escalations", "/poll-status",
+    "/drift", "/goal-progress", "/pool", "/reasoner-cost",
+    "/anomaly", "/sla", "/velocity", "/schedule", "/cost-summary",
+    "/session-report", "/cache", "/rate-limit", "/recovery",
+    "/lifecycle", "/cost-report", "/decompose", "/memory",
+    "/dep-graph", "/approvals", "/approve", "/reject", "/fleet-diff",
+    "/template", "/difficulty", "/smart-nudge", "/utilization",
+    "/detect-template", "/fleet-search", "/nudge-stats", "/allocation",
+    "/graduation", "/refine", "/export", "/clear",
+];
+/**
+ * Generate bash completion script.
+ */
+export function generateBashCompletion() {
+    const cmds = CLI_COMMANDS.join(" ");
+    const flags = CLI_FLAGS.join(" ");
+    return `# aoaoe bash completion
+# Add to ~/.bashrc: eval "$(aoaoe completions bash)"
+_aoaoe() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  if [[ "\${cur}" == --* ]]; then
+    COMPREPLY=($(compgen -W "${flags}" -- "\${cur}"))
+  elif [[ "\${COMP_CWORD}" -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "${cmds}" -- "\${cur}"))
+  fi
+}
+complete -F _aoaoe aoaoe
+`;
+}
+/**
+ * Generate zsh completion script.
+ */
+export function generateZshCompletion() {
+    const cmdList = CLI_COMMANDS.map((c) => `'${c}'`).join(" ");
+    const flagList = CLI_FLAGS.map((f) => `'${f}'`).join(" ");
+    return `# aoaoe zsh completion
+# Add to ~/.zshrc: eval "$(aoaoe completions zsh)"
+_aoaoe() {
+  local -a commands flags
+  commands=(${cmdList})
+  flags=(${flagList})
+  
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+  elif [[ "\${words[CURRENT]}" == --* ]]; then
+    _describe 'flag' flags
+  fi
+}
+compdef _aoaoe aoaoe
+`;
+}
+/**
+ * Generate fish completion script.
+ */
+export function generateFishCompletion() {
+    const lines = [
+        "# aoaoe fish completion",
+        "# Add to ~/.config/fish/completions/aoaoe.fish",
+    ];
+    for (const cmd of CLI_COMMANDS) {
+        lines.push(`complete -c aoaoe -n '__fish_use_subcommand' -a '${cmd}'`);
+    }
+    for (const flag of CLI_FLAGS) {
+        lines.push(`complete -c aoaoe -l '${flag.replace(/^--/, "")}'`);
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Generate completion script for the specified shell.
+ */
+export function generateCompletion(shell) {
+    switch (shell) {
+        case "bash": return generateBashCompletion();
+        case "zsh": return generateZshCompletion();
+        case "fish": return generateFishCompletion();
+    }
+}
+/**
+ * List all available commands for help display.
+ */
+export function formatCommandList() {
+    const lines = [];
+    lines.push(`  CLI commands (${CLI_COMMANDS.length}):`);
+    lines.push(`    ${CLI_COMMANDS.join(", ")}`);
+    lines.push("");
+    lines.push(`  TUI slash commands (${TUI_COMMANDS.length}):`);
+    // group in rows of 6
+    for (let i = 0; i < TUI_COMMANDS.length; i += 6) {
+        lines.push(`    ${TUI_COMMANDS.slice(i, i + 6).join("  ")}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=cli-completions.js.map

package/dist/config.d.ts

@@ -91,6 +91,9 @@ export declare function parseCliArgs(argv: string[]): {
     replaySpeed?: number;
     replayLast?: string;
     registerTitle?: string;
+    runService: boolean;
+    runCompletions: boolean;
+    completionsShell?: string;
 };
 export declare function printHelp(): void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -359,7 +359,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, showTasksJson: false, runProgress: false, progressSince: undefined, progressJson: false, runHealth: false, healthJson: false, runSummary: false, runAdopt: false, adoptTemplate: undefined, showHistory: false, showStatus: false, runRunbook: false, runbookJson: false, runbookSection: undefined, runIncident: false, incidentSince: undefined, incidentLimit: undefined, incidentJson: false, incidentNdjson: false, incidentWatch: false, incidentChangesOnly: false, incidentHeartbeatSec: undefined, incidentIntervalMs: undefined, runSupervisor: false, supervisorAll: false, supervisorSince: undefined, supervisorLimit: undefined, supervisorJson: false, supervisorNdjson: false, supervisorWatch: false, supervisorChangesOnly: false, supervisorHeartbeatSec: undefined, supervisorIntervalMs: undefined, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runBackup: false, backupOutput: undefined, runRestore: false, restoreInput: undefined, runSync: false, syncAction: undefined, syncRemote: undefined, runWeb: false, webPort: undefined, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, exportTasks: false, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined };
+    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showTasksJson: false, runProgress: false, progressSince: undefined, progressJson: false, runHealth: false, healthJson: false, runSummary: false, runAdopt: false, adoptTemplate: undefined, showHistory: false, showStatus: false, runRunbook: false, runbookJson: false, runbookSection: undefined, runIncident: false, incidentSince: undefined, incidentLimit: undefined, incidentJson: false, incidentNdjson: false, incidentWatch: false, incidentChangesOnly: false, incidentHeartbeatSec: undefined, incidentIntervalMs: undefined, runSupervisor: false, supervisorAll: false, supervisorSince: undefined, supervisorLimit: undefined, supervisorJson: false, supervisorNdjson: false, supervisorWatch: false, supervisorChangesOnly: false, supervisorHeartbeatSec: undefined, supervisorIntervalMs: undefined, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runBackup: false, backupOutput: undefined, runRestore: false, restoreInput: undefined, runSync: false, syncAction: undefined, syncRemote: undefined, runWeb: false, webPort: undefined, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, exportTasks: false, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined, runService: false, runCompletions: false, completionsShell: undefined };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -573,6 +573,13 @@ export function parseCliArgs(argv) {
     if (argv[2] === "doctor") {
         return { ...defaults, runDoctor: true };
     }
+    if (argv[2] === "service") {
+        return { ...defaults, runService: true };
+    }
+    if (argv[2] === "completions") {
+        const shell = argv[3] ?? "bash";
+        return { ...defaults, runCompletions: true, completionsShell: shell };
+    }
     if (argv[2] === "backup") {
         const output = argv[3] && !argv[3].startsWith("-") ? argv[3] : undefined;
         return { ...defaults, runBackup: true, backupOutput: output };

package/dist/fleet-federation.d.ts

@@ -0,0 +1,34 @@
+export interface FederationPeer {
+    name: string;
+    url: string;
+    lastSeenAt?: number;
+    status: "online" | "offline" | "unknown";
+}
+export interface FederatedFleetState {
+    peer: string;
+    sessions: number;
+    activeTasks: number;
+    fleetHealth: number;
+    totalCostUsd: number;
+    lastUpdatedAt: number;
+}
+export interface FederationOverview {
+    peers: FederatedFleetState[];
+    totalSessions: number;
+    totalActiveTasks: number;
+    averageHealth: number;
+    totalCostUsd: number;
+}
+/**
+ * Fetch fleet state from a peer daemon's health endpoint.
+ */
+export declare function fetchPeerState(peer: FederationPeer, timeoutMs?: number): Promise<FederatedFleetState | null>;
+/**
+ * Aggregate fleet state from all peers into an overview.
+ */
+export declare function aggregateFederation(states: FederatedFleetState[]): FederationOverview;
+/**
+ * Format federation overview for TUI display.
+ */
+export declare function formatFederationOverview(overview: FederationOverview): string[];
+//# sourceMappingURL=fleet-federation.d.ts.map

package/dist/fleet-federation.js

@@ -0,0 +1,55 @@
+// fleet-federation.ts — coordinate across multiple aoaoe daemons via HTTP.
+// each daemon exposes a lightweight status endpoint; the federation client
+// aggregates fleet state across hosts for unified monitoring.
+/**
+ * Fetch fleet state from a peer daemon's health endpoint.
+ */
+export async function fetchPeerState(peer, timeoutMs = 5000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(`${peer.url}/health`, { signal: controller.signal });
+        clearTimeout(timer);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        return {
+            peer: peer.name,
+            sessions: data.sessions ?? 0,
+            activeTasks: data.activeTasks ?? 0,
+            fleetHealth: data.fleetHealth ?? 0,
+            totalCostUsd: data.totalCostUsd ?? 0,
+            lastUpdatedAt: Date.now(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Aggregate fleet state from all peers into an overview.
+ */
+export function aggregateFederation(states) {
+    const totalSessions = states.reduce((s, p) => s + p.sessions, 0);
+    const totalActiveTasks = states.reduce((s, p) => s + p.activeTasks, 0);
+    const totalCost = states.reduce((s, p) => s + p.totalCostUsd, 0);
+    const avgHealth = states.length > 0
+        ? Math.round(states.reduce((s, p) => s + p.fleetHealth, 0) / states.length)
+        : 0;
+    return { peers: states, totalSessions, totalActiveTasks, averageHealth: avgHealth, totalCostUsd: totalCost };
+}
+/**
+ * Format federation overview for TUI display.
+ */
+export function formatFederationOverview(overview) {
+    if (overview.peers.length === 0)
+        return ["  (no federation peers configured)"];
+    const lines = [];
+    lines.push(`  Federation: ${overview.peers.length} peers, ${overview.totalSessions} sessions, health ${overview.averageHealth}/100, $${overview.totalCostUsd.toFixed(2)} total`);
+    for (const p of overview.peers) {
+        const age = Math.round((Date.now() - p.lastUpdatedAt) / 60_000);
+        lines.push(`  ${p.peer}: ${p.sessions} sessions, ${p.activeTasks} active, health ${p.fleetHealth}/100, $${p.totalCostUsd.toFixed(2)} (${age}m ago)`);
+    }
+    return lines;
+}
+//# sourceMappingURL=fleet-federation.js.map