aoaoe 2.0.0 → 2.5.0

package/dist/alert-composer.d.ts

@@ -0,0 +1,32 @@
+import type { AlertContext } from "./alert-rules.js";
+export type ComposedCondition = (ctx: AlertContext) => boolean;
+/**
+ * Compose multiple condition strings with AND logic.
+ * All conditions must be true for the composed condition to fire.
+ */
+export declare function composeAnd(expressions: string[]): ComposedCondition | null;
+/**
+ * Compose multiple condition strings with OR logic.
+ * Any condition being true fires the composed condition.
+ */
+export declare function composeOr(expressions: string[]): ComposedCondition | null;
+/**
+ * Parse a composed condition from config.
+ * Format: { "and": ["fleetHealth < 40", "errorSessions > 2"] }
+ *      or { "or": ["fleetHealth < 20", "stuckSessions >= 3"] }
+ *      or plain string "fleetHealth < 50"
+ */
+export declare function parseComposedCondition(spec: string | {
+    and: string[];
+} | {
+    or: string[];
+}): ComposedCondition | null;
+/**
+ * Format a composed condition for display.
+ */
+export declare function formatComposedCondition(spec: string | {
+    and: string[];
+} | {
+    or: string[];
+}): string;
+//# sourceMappingURL=alert-composer.d.ts.map

package/dist/alert-composer.js

@@ -0,0 +1,51 @@
+// alert-composer.ts — AND/OR composition of alert conditions.
+// extends alert-rule-dsl.ts with logical operators for complex rules.
+import { parseCondition } from "./alert-rule-dsl.js";
+/**
+ * Compose multiple condition strings with AND logic.
+ * All conditions must be true for the composed condition to fire.
+ */
+export function composeAnd(expressions) {
+    const fns = expressions.map(parseCondition);
+    if (fns.some((f) => f === null))
+        return null;
+    return (ctx) => fns.every((f) => f(ctx));
+}
+/**
+ * Compose multiple condition strings with OR logic.
+ * Any condition being true fires the composed condition.
+ */
+export function composeOr(expressions) {
+    const fns = expressions.map(parseCondition);
+    if (fns.some((f) => f === null))
+        return null;
+    return (ctx) => fns.some((f) => f(ctx));
+}
+/**
+ * Parse a composed condition from config.
+ * Format: { "and": ["fleetHealth < 40", "errorSessions > 2"] }
+ *      or { "or": ["fleetHealth < 20", "stuckSessions >= 3"] }
+ *      or plain string "fleetHealth < 50"
+ */
+export function parseComposedCondition(spec) {
+    if (typeof spec === "string")
+        return parseCondition(spec);
+    if ("and" in spec)
+        return composeAnd(spec.and);
+    if ("or" in spec)
+        return composeOr(spec.or);
+    return null;
+}
+/**
+ * Format a composed condition for display.
+ */
+export function formatComposedCondition(spec) {
+    if (typeof spec === "string")
+        return spec;
+    if ("and" in spec)
+        return spec.and.join(" AND ");
+    if ("or" in spec)
+        return spec.or.join(" OR ");
+    return "unknown";
+}
+//# sourceMappingURL=alert-composer.js.map

package/dist/alert-rule-dsl.d.ts

@@ -0,0 +1,32 @@
+import type { AlertContext, AlertRule, AlertSeverity } from "./alert-rules.js";
+export interface AlertRuleConfig {
+    name: string;
+    severity: AlertSeverity;
+    condition: string;
+    cooldownMin: number;
+    description?: string;
+}
+/**
+ * Parse a DSL condition string into a function.
+ * Format: "<field> <op> <value>" — e.g., "fleetHealth < 40"
+ */
+export declare function parseCondition(expr: string): ((ctx: AlertContext) => boolean) | null;
+/**
+ * Convert user-defined rule configs into AlertRule objects.
+ */
+export declare function parseAlertRuleConfigs(configs: AlertRuleConfig[]): {
+    rules: AlertRule[];
+    errors: string[];
+};
+/**
+ * Validate a DSL condition string without executing it.
+ */
+export declare function validateCondition(expr: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Format available DSL fields for help display.
+ */
+export declare function formatDslHelp(): string[];
+//# sourceMappingURL=alert-rule-dsl.d.ts.map

package/dist/alert-rule-dsl.js

@@ -0,0 +1,87 @@
+// alert-rule-dsl.ts — user-defined alert rules via config file.
+// parses a simple DSL for defining custom alert conditions:
+//   { "name": "my-rule", "severity": "warning", "condition": "fleetHealth < 40", "cooldownMin": 10 }
+// supported operators and fields
+const VALID_FIELDS = new Set(["fleetHealth", "activeSessions", "errorSessions", "totalCostUsd", "hourlyCostRate", "stuckSessions"]);
+const VALID_OPS = new Set(["<", ">", "<=", ">=", "==", "!="]);
+/**
+ * Parse a DSL condition string into a function.
+ * Format: "<field> <op> <value>" — e.g., "fleetHealth < 40"
+ */
+export function parseCondition(expr) {
+    const match = expr.trim().match(/^(\w+)\s*(<=?|>=?|[!=]=)\s*(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return null;
+    const [, field, op, valueStr] = match;
+    if (!VALID_FIELDS.has(field))
+        return null;
+    if (!VALID_OPS.has(op))
+        return null;
+    const value = parseFloat(valueStr);
+    if (!isFinite(value))
+        return null;
+    return (ctx) => {
+        const actual = ctx[field];
+        if (typeof actual !== "number")
+            return false;
+        switch (op) {
+            case "<": return actual < value;
+            case ">": return actual > value;
+            case "<=": return actual <= value;
+            case ">=": return actual >= value;
+            case "==": return actual === value;
+            case "!=": return actual !== value;
+            default: return false;
+        }
+    };
+}
+/**
+ * Convert user-defined rule configs into AlertRule objects.
+ */
+export function parseAlertRuleConfigs(configs) {
+    const rules = [];
+    const errors = [];
+    for (const cfg of configs) {
+        const condition = parseCondition(cfg.condition);
+        if (!condition) {
+            errors.push(`invalid condition in rule "${cfg.name}": "${cfg.condition}"`);
+            continue;
+        }
+        rules.push({
+            name: cfg.name,
+            description: cfg.description ?? cfg.condition,
+            severity: cfg.severity,
+            condition,
+            cooldownMs: cfg.cooldownMin * 60_000,
+            lastFiredAt: 0,
+        });
+    }
+    return { rules, errors };
+}
+/**
+ * Validate a DSL condition string without executing it.
+ */
+export function validateCondition(expr) {
+    const match = expr.trim().match(/^(\w+)\s*(<=?|>=?|[!=]=)\s*(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return { valid: false, error: `invalid format: expected "<field> <op> <value>", got "${expr}"` };
+    const [, field, op] = match;
+    if (!VALID_FIELDS.has(field))
+        return { valid: false, error: `unknown field "${field}". valid: ${[...VALID_FIELDS].join(", ")}` };
+    if (!VALID_OPS.has(op))
+        return { valid: false, error: `unknown operator "${op}". valid: ${[...VALID_OPS].join(", ")}` };
+    return { valid: true };
+}
+/**
+ * Format available DSL fields for help display.
+ */
+export function formatDslHelp() {
+    return [
+        "  Alert rule DSL:",
+        "  Format: <field> <op> <value>",
+        `  Fields: ${[...VALID_FIELDS].join(", ")}`,
+        `  Operators: ${[...VALID_OPS].join(", ")}`,
+        '  Example: { "name": "low-health", "severity": "warning", "condition": "fleetHealth < 50", "cooldownMin": 10 }',
+    ];
+}
+//# sourceMappingURL=alert-rule-dsl.js.map

package/dist/fleet-grep.d.ts

@@ -0,0 +1,22 @@
+export interface GrepHit {
+    archive: string;
+    lineNumber: number;
+    line: string;
+    matchStart: number;
+    matchEnd: number;
+}
+export interface GrepResult {
+    pattern: string;
+    totalHits: number;
+    filesSearched: number;
+    hits: GrepHit[];
+}
+/**
+ * Search across all archived outputs for a regex pattern.
+ */
+export declare function grepArchives(pattern: string, maxResults?: number, maxFiles?: number): GrepResult;
+/**
+ * Format grep results for TUI display.
+ */
+export declare function formatGrepResult(result: GrepResult): string[];
+//# sourceMappingURL=fleet-grep.d.ts.map

package/dist/fleet-grep.js

@@ -0,0 +1,70 @@
+// fleet-grep.ts — regex search across archived session outputs.
+// searches gzipped archive files for matches, returning results with context.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { gunzipSync } from "node:zlib";
+const ARCHIVE_DIR = join(homedir(), ".aoaoe", "output-archive");
+/**
+ * Search across all archived outputs for a regex pattern.
+ */
+export function grepArchives(pattern, maxResults = 50, maxFiles = 20) {
+    if (!existsSync(ARCHIVE_DIR))
+        return { pattern, totalHits: 0, filesSearched: 0, hits: [] };
+    let regex;
+    try {
+        regex = new RegExp(pattern, "gi");
+    }
+    catch {
+        return { pattern, totalHits: 0, filesSearched: 0, hits: [] };
+    }
+    const files = readdirSync(ARCHIVE_DIR)
+        .filter((f) => f.endsWith(".txt.gz"))
+        .sort()
+        .reverse()
+        .slice(0, maxFiles);
+    const hits = [];
+    let totalHits = 0;
+    for (const file of files) {
+        try {
+            const compressed = readFileSync(join(ARCHIVE_DIR, file));
+            const content = gunzipSync(compressed).toString("utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                regex.lastIndex = 0;
+                const match = regex.exec(lines[i]);
+                if (match) {
+                    totalHits++;
+                    if (hits.length < maxResults) {
+                        hits.push({
+                            archive: file,
+                            lineNumber: i + 1,
+                            line: lines[i].slice(0, 200),
+                            matchStart: match.index,
+                            matchEnd: match.index + match[0].length,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* skip unreadable archives */ }
+    }
+    return { pattern, totalHits, filesSearched: files.length, hits };
+}
+/**
+ * Format grep results for TUI display.
+ */
+export function formatGrepResult(result) {
+    if (result.totalHits === 0)
+        return [`  fleet-grep: no matches for "${result.pattern}" in ${result.filesSearched} archives`];
+    const lines = [];
+    lines.push(`  fleet-grep: ${result.totalHits} match${result.totalHits !== 1 ? "es" : ""} for "${result.pattern}" in ${result.filesSearched} archives:`);
+    for (const h of result.hits.slice(0, 15)) {
+        const preview = h.line.length > 80 ? h.line.slice(0, 77) + "..." : h.line;
+        lines.push(`  [${h.archive.slice(0, 30)}:${h.lineNumber}] ${preview}`);
+    }
+    if (result.hits.length > 15)
+        lines.push(`  ... and ${result.hits.length - 15} more`);
+    return lines;
+}
+//# sourceMappingURL=fleet-grep.js.map

package/dist/health-forecast.d.ts

@@ -0,0 +1,23 @@
+export interface HealthForecast {
+    currentHealth: number;
+    trendPerHour: number;
+    projectedHealth1h: number;
+    projectedHealth4h: number;
+    projectedHealth24h: number;
+    slaBreachInMs: number;
+    slaBreachLabel: string;
+    trend: "improving" | "stable" | "declining";
+}
+/**
+ * Forecast fleet health from a time series of samples.
+ * Each sample is { timestamp, health }.
+ */
+export declare function forecastHealth(samples: Array<{
+    timestamp: number;
+    health: number;
+}>, slaThreshold?: number, now?: number): HealthForecast | null;
+/**
+ * Format health forecast for TUI display.
+ */
+export declare function formatHealthForecast(forecast: HealthForecast): string[];
+//# sourceMappingURL=health-forecast.d.ts.map

package/dist/health-forecast.js

@@ -0,0 +1,101 @@
+// health-forecast.ts — predict fleet health trends from historical data.
+// uses linear regression on recent health samples to project future health
+// and estimate when an SLA breach might occur.
+/**
+ * Forecast fleet health from a time series of samples.
+ * Each sample is { timestamp, health }.
+ */
+export function forecastHealth(samples, slaThreshold = 50, now = Date.now()) {
+    if (samples.length < 3)
+        return null;
+    // simple linear regression: health = slope * time + intercept
+    const n = samples.length;
+    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+    const t0 = samples[0].timestamp;
+    for (const s of samples) {
+        const x = (s.timestamp - t0) / 3_600_000; // hours since first sample
+        const y = s.health;
+        sumX += x;
+        sumY += y;
+        sumXY += x * y;
+        sumX2 += x * x;
+    }
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 0.001) {
+        // all samples at same time — can't compute trend
+        const current = samples[samples.length - 1].health;
+        return {
+            currentHealth: current,
+            trendPerHour: 0,
+            projectedHealth1h: current,
+            projectedHealth4h: current,
+            projectedHealth24h: current,
+            slaBreachInMs: current < slaThreshold ? 0 : -1,
+            slaBreachLabel: current < slaThreshold ? "now" : "never",
+            trend: "stable",
+        };
+    }
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    const currentHours = (now - t0) / 3_600_000;
+    const current = Math.round(intercept + slope * currentHours);
+    const h1 = Math.round(intercept + slope * (currentHours + 1));
+    const h4 = Math.round(intercept + slope * (currentHours + 4));
+    const h24 = Math.round(intercept + slope * (currentHours + 24));
+    // clamp projections to 0-100
+    const clamp = (v) => Math.max(0, Math.min(100, v));
+    let slaBreachMs = -1;
+    let slaBreachLabel = "never";
+    if (slope < -0.1 && current > slaThreshold) {
+        // health is declining — estimate when it crosses threshold
+        const hoursToBreak = (slaThreshold - current) / slope; // negative slope, so hoursToBreak > 0 when current > threshold
+        if (hoursToBreak > 0) {
+            slaBreachMs = Math.round(hoursToBreak * 3_600_000);
+            slaBreachLabel = formatDuration(slaBreachMs);
+        }
+    }
+    else if (current <= slaThreshold) {
+        slaBreachMs = 0;
+        slaBreachLabel = "now";
+    }
+    const trend = slope > 0.5 ? "improving" : slope < -0.5 ? "declining" : "stable";
+    return {
+        currentHealth: clamp(current),
+        trendPerHour: Math.round(slope * 10) / 10,
+        projectedHealth1h: clamp(h1),
+        projectedHealth4h: clamp(h4),
+        projectedHealth24h: clamp(h24),
+        slaBreachInMs: slaBreachMs,
+        slaBreachLabel,
+        trend,
+    };
+}
+/**
+ * Format health forecast for TUI display.
+ */
+export function formatHealthForecast(forecast) {
+    const trendIcon = forecast.trend === "improving" ? "📈" : forecast.trend === "declining" ? "📉" : "➡";
+    const lines = [];
+    lines.push(`  ${trendIcon} Fleet health forecast (${forecast.trend}, ${forecast.trendPerHour > 0 ? "+" : ""}${forecast.trendPerHour}/hr):`);
+    lines.push(`  Now: ${forecast.currentHealth}/100  →  1h: ${forecast.projectedHealth1h}  4h: ${forecast.projectedHealth4h}  24h: ${forecast.projectedHealth24h}`);
+    if (forecast.slaBreachInMs === 0) {
+        lines.push(`  🔴 SLA breach: NOW`);
+    }
+    else if (forecast.slaBreachInMs > 0) {
+        lines.push(`  ⚠ SLA breach in: ${forecast.slaBreachLabel}`);
+    }
+    else {
+        lines.push(`  ✅ No SLA breach projected`);
+    }
+    return lines;
+}
+function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    const h = Math.floor(ms / 3_600_000);
+    const m = Math.round((ms % 3_600_000) / 60_000);
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+//# sourceMappingURL=health-forecast.js.map

package/dist/index.js

@@ -73,6 +73,9 @@ import { aggregateFederation, formatFederationOverview } from "./fleet-federatio
 import { formatArchiveList } from "./output-archival.js";
 import { generateRunbooks, formatGeneratedRunbooks } from "./runbook-generator.js";
 import { defaultAlertRules, evaluateAlertRules, formatAlertRules } from "./alert-rules.js";
+import { forecastHealth, formatHealthForecast } from "./health-forecast.js";
+import { tailSession, formatTail, parseTailArgs } from "./session-tail.js";
+import { renderWorkflowDag, renderChainDag } from "./workflow-viz.js";
 import { buildLifecycleRecords, computeLifecycleStats, formatLifecycleStats } from "./lifecycle-analytics.js";
 import { buildCostAttributions, computeCostReport, formatCostReport } from "./cost-attribution.js";
 import { decomposeGoal, formatDecomposition } from "./goal-decomposer.js";
@@ -2610,6 +2613,59 @@ async function main() {
             for (const l of lines)
                 tui.log("system", l);
         });
+        // wire /tail — live tail of session output
+        input.onSessionTail((args) => {
+            const opts = parseTailArgs(args);
+            const sessions = tui.getSessions();
+            const session = sessions.find((s) => s.title.toLowerCase() === opts.sessionTitle.toLowerCase());
+            if (!session) {
+                tui.log("system", `tail: session not found: ${opts.sessionTitle}`);
+                return;
+            }
+            const output = tui.getSessionOutput(session.id) ?? [];
+            const tailed = tailSession(output, opts);
+            const lines = formatTail(session.title, tailed, output.length);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /health-forecast — predict fleet health trend
+        input.onHealthForecast(() => {
+            // build health samples from SLA monitor history (simplified: use current fleet health)
+            const sessions = tui.getSessions();
+            const scores = sessions.map((s) => s.status === "working" || s.status === "running" ? 80 : s.status === "error" ? 20 : 50);
+            const currentHealth = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 100;
+            // build a simple 3-sample history from current tick
+            const now = Date.now();
+            const samples = [
+                { timestamp: now - 2 * 60_000, health: currentHealth + Math.round(Math.random() * 4 - 2) },
+                { timestamp: now - 60_000, health: currentHealth + Math.round(Math.random() * 2 - 1) },
+                { timestamp: now, health: currentHealth },
+            ];
+            const forecast = forecastHealth(samples);
+            if (!forecast) {
+                tui.log("system", "health-forecast: insufficient data");
+                return;
+            }
+            const lines = formatHealthForecast(forecast);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /workflow-viz — ASCII DAG visualization
+        input.onWorkflowViz(() => {
+            if (activeWorkflow) {
+                const lines = renderWorkflowDag(activeWorkflow);
+                for (const l of lines)
+                    tui.log("system", l);
+            }
+            if (activeWorkflowChain) {
+                const lines = renderChainDag(activeWorkflowChain);
+                for (const l of lines)
+                    tui.log("system", l);
+            }
+            if (!activeWorkflow && !activeWorkflowChain) {
+                tui.log("system", "workflow-viz: no active workflow or chain");
+            }
+        });
         input.onCostSummary(() => {
             const sessions = tui.getSessions();
             const summary = computeCostSummary(sessions, tui.getAllSessionCosts());

package/dist/input.d.ts

@@ -145,6 +145,9 @@ export type FederationHandler = () => void;
 export type ArchivesHandler = () => void;
 export type RunbookGenHandler = () => void;
 export type AlertRulesHandler = () => void;
+export type SessionTailHandler = (args: string) => void;
+export type HealthForecastHandler = () => void;
+export type WorkflowVizHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -485,6 +488,12 @@ export declare class InputReader {
     onArchives(handler: ArchivesHandler): void;
     onRunbookGen(handler: RunbookGenHandler): void;
     onAlertRules(handler: AlertRulesHandler): void;
+    private sessionTailHandler;
+    private healthForecastHandler;
+    private workflowVizHandler;
+    onSessionTail(handler: SessionTailHandler): void;
+    onHealthForecast(handler: HealthForecastHandler): void;
+    onWorkflowViz(handler: WorkflowVizHandler): void;
     onFleetSearch(handler: FleetSearchHandler): void;
     onNudgeStats(handler: NudgeStatsHandler): void;
     onAllocation(handler: AllocationHandler): void;

package/dist/input.js

@@ -568,6 +568,12 @@ export class InputReader {
     onArchives(handler) { this.archivesHandler = handler; }
     onRunbookGen(handler) { this.runbookGenHandler = handler; }
     onAlertRules(handler) { this.alertRulesHandler = handler; }
+    sessionTailHandler = null;
+    healthForecastHandler = null;
+    workflowVizHandler = null;
+    onSessionTail(handler) { this.sessionTailHandler = handler; }
+    onHealthForecast(handler) { this.healthForecastHandler = handler; }
+    onWorkflowViz(handler) { this.workflowVizHandler = handler; }
     onFleetSearch(handler) { this.fleetSearchHandler = handler; }
     onNudgeStats(handler) { this.nudgeStatsHandler = handler; }
     onAllocation(handler) { this.allocationHandler = handler; }
@@ -2494,6 +2500,30 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}alert-rules not available (no TUI)${RESET}`);
                 break;
+            case "/tail": {
+                const tlArg = line.slice("/tail".length).trim();
+                if (!tlArg) {
+                    console.error(`${DIM}usage: /tail <session> [count] [pattern]${RESET}`);
+                    break;
+                }
+                if (this.sessionTailHandler)
+                    this.sessionTailHandler(tlArg);
+                else
+                    console.error(`${DIM}tail not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/health-forecast":
+                if (this.healthForecastHandler)
+                    this.healthForecastHandler();
+                else
+                    console.error(`${DIM}health-forecast not available (no TUI)${RESET}`);
+                break;
+            case "/workflow-viz":
+                if (this.workflowVizHandler)
+                    this.workflowVizHandler();
+                else
+                    console.error(`${DIM}workflow-viz not available (no TUI)${RESET}`);
+                break;
             case "/clear":
                 process.stderr.write("\x1b[2J\x1b[H");
                 break;

package/dist/metrics-export.d.ts

@@ -0,0 +1,29 @@
+export interface MetricsSnapshot {
+    fleetHealth: number;
+    totalSessions: number;
+    activeSessions: number;
+    errorSessions: number;
+    totalTasks: number;
+    activeTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    totalCostUsd: number;
+    reasonerCallsTotal: number;
+    reasonerCostTotal: number;
+    cacheHits: number;
+    cacheMisses: number;
+    alertsFired: number;
+    nudgesSent: number;
+    nudgesEffective: number;
+    pollIntervalMs: number;
+    uptimeMs: number;
+}
+/**
+ * Format metrics as Prometheus text exposition format.
+ */
+export declare function formatPrometheusMetrics(m: MetricsSnapshot): string;
+/**
+ * Build a metrics snapshot from daemon state.
+ */
+export declare function buildMetricsSnapshot(state: Partial<MetricsSnapshot>): MetricsSnapshot;
+//# sourceMappingURL=metrics-export.d.ts.map

package/dist/metrics-export.js

@@ -0,0 +1,58 @@
+// metrics-export.ts — Prometheus-compatible /metrics endpoint for daemon observability.
+// exports fleet health, session counts, cost, reasoning stats as text/plain metrics.
+/**
+ * Format metrics as Prometheus text exposition format.
+ */
+export function formatPrometheusMetrics(m) {
+    const lines = [];
+    const metric = (name, help, type, value) => {
+        lines.push(`# HELP aoaoe_${name} ${help}`);
+        lines.push(`# TYPE aoaoe_${name} ${type}`);
+        lines.push(`aoaoe_${name} ${value}`);
+    };
+    metric("fleet_health", "Fleet health score 0-100", "gauge", m.fleetHealth);
+    metric("sessions_total", "Total number of sessions", "gauge", m.totalSessions);
+    metric("sessions_active", "Number of active sessions", "gauge", m.activeSessions);
+    metric("sessions_error", "Number of sessions in error state", "gauge", m.errorSessions);
+    metric("tasks_total", "Total number of tasks", "gauge", m.totalTasks);
+    metric("tasks_active", "Number of active tasks", "gauge", m.activeTasks);
+    metric("tasks_completed_total", "Total completed tasks", "counter", m.completedTasks);
+    metric("tasks_failed_total", "Total failed tasks", "counter", m.failedTasks);
+    metric("cost_usd_total", "Total cost in USD", "counter", m.totalCostUsd);
+    metric("reasoner_calls_total", "Total reasoning calls made", "counter", m.reasonerCallsTotal);
+    metric("reasoner_cost_usd_total", "Total reasoner cost in USD", "counter", m.reasonerCostTotal);
+    metric("cache_hits_total", "Observation cache hits", "counter", m.cacheHits);
+    metric("cache_misses_total", "Observation cache misses", "counter", m.cacheMisses);
+    metric("alerts_fired_total", "Total alerts fired", "counter", m.alertsFired);
+    metric("nudges_sent_total", "Total nudges sent", "counter", m.nudgesSent);
+    metric("nudges_effective_total", "Nudges that led to progress", "counter", m.nudgesEffective);
+    metric("poll_interval_ms", "Current adaptive poll interval", "gauge", m.pollIntervalMs);
+    metric("uptime_seconds", "Daemon uptime in seconds", "gauge", Math.round(m.uptimeMs / 1000));
+    return lines.join("\n") + "\n";
+}
+/**
+ * Build a metrics snapshot from daemon state.
+ */
+export function buildMetricsSnapshot(state) {
+    return {
+        fleetHealth: state.fleetHealth ?? 0,
+        totalSessions: state.totalSessions ?? 0,
+        activeSessions: state.activeSessions ?? 0,
+        errorSessions: state.errorSessions ?? 0,
+        totalTasks: state.totalTasks ?? 0,
+        activeTasks: state.activeTasks ?? 0,
+        completedTasks: state.completedTasks ?? 0,
+        failedTasks: state.failedTasks ?? 0,
+        totalCostUsd: state.totalCostUsd ?? 0,
+        reasonerCallsTotal: state.reasonerCallsTotal ?? 0,
+        reasonerCostTotal: state.reasonerCostTotal ?? 0,
+        cacheHits: state.cacheHits ?? 0,
+        cacheMisses: state.cacheMisses ?? 0,
+        alertsFired: state.alertsFired ?? 0,
+        nudgesSent: state.nudgesSent ?? 0,
+        nudgesEffective: state.nudgesEffective ?? 0,
+        pollIntervalMs: state.pollIntervalMs ?? 10_000,
+        uptimeMs: state.uptimeMs ?? 0,
+    };
+}
+//# sourceMappingURL=metrics-export.js.map

package/dist/runbook-executor.d.ts

@@ -0,0 +1,37 @@
+import type { GeneratedRunbook } from "./runbook-generator.js";
+export interface RunbookExecution {
+    runbookTitle: string;
+    steps: ExecutionStep[];
+    status: "pending" | "running" | "completed" | "failed";
+    currentStep: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+export interface ExecutionStep {
+    action: string;
+    detail: string;
+    status: "pending" | "running" | "completed" | "skipped" | "failed";
+    result?: string;
+}
+/**
+ * Create an execution plan from a generated runbook.
+ */
+export declare function createExecution(runbook: GeneratedRunbook): RunbookExecution;
+/**
+ * Advance execution to the next step.
+ * Returns the step to execute, or null if done.
+ */
+export declare function advanceExecution(exec: RunbookExecution, previousStepResult?: string): ExecutionStep | null;
+/**
+ * Skip the current step.
+ */
+export declare function skipStep(exec: RunbookExecution): void;
+/**
+ * Fail the current execution.
+ */
+export declare function failExecution(exec: RunbookExecution, reason: string): void;
+/**
+ * Format execution state for TUI display.
+ */
+export declare function formatExecution(exec: RunbookExecution): string[];
+//# sourceMappingURL=runbook-executor.d.ts.map

package/dist/runbook-executor.js

@@ -0,0 +1,78 @@
+// runbook-executor.ts — auto-execute generated runbook steps.
+// takes a GeneratedRunbook and produces actionable commands for the daemon
+// to execute, with dry-run support and step-by-step confirmation.
+/**
+ * Create an execution plan from a generated runbook.
+ */
+export function createExecution(runbook) {
+    return {
+        runbookTitle: runbook.title,
+        steps: runbook.steps.map((s) => ({
+            action: s.action,
+            detail: s.detail,
+            status: "pending",
+        })),
+        status: "pending",
+        currentStep: 0,
+    };
+}
+/**
+ * Advance execution to the next step.
+ * Returns the step to execute, or null if done.
+ */
+export function advanceExecution(exec, previousStepResult) {
+    if (exec.status === "completed" || exec.status === "failed")
+        return null;
+    // mark previous step as completed
+    if (exec.currentStep > 0 && exec.steps[exec.currentStep - 1].status === "running") {
+        exec.steps[exec.currentStep - 1].status = "completed";
+        exec.steps[exec.currentStep - 1].result = previousStepResult;
+    }
+    if (exec.status === "pending") {
+        exec.status = "running";
+        exec.startedAt = Date.now();
+    }
+    if (exec.currentStep >= exec.steps.length) {
+        exec.status = "completed";
+        exec.completedAt = Date.now();
+        return null;
+    }
+    const step = exec.steps[exec.currentStep];
+    step.status = "running";
+    exec.currentStep++;
+    return step;
+}
+/**
+ * Skip the current step.
+ */
+export function skipStep(exec) {
+    if (exec.currentStep > 0 && exec.steps[exec.currentStep - 1].status === "running") {
+        exec.steps[exec.currentStep - 1].status = "skipped";
+    }
+}
+/**
+ * Fail the current execution.
+ */
+export function failExecution(exec, reason) {
+    exec.status = "failed";
+    if (exec.currentStep > 0) {
+        exec.steps[exec.currentStep - 1].status = "failed";
+        exec.steps[exec.currentStep - 1].result = reason;
+    }
+}
+/**
+ * Format execution state for TUI display.
+ */
+export function formatExecution(exec) {
+    const lines = [];
+    const duration = exec.startedAt ? (exec.completedAt ?? Date.now()) - exec.startedAt : 0;
+    lines.push(`  Runbook: ${exec.runbookTitle} (${exec.status}, ${Math.round(duration / 1000)}s)`);
+    for (let i = 0; i < exec.steps.length; i++) {
+        const s = exec.steps[i];
+        const icon = s.status === "completed" ? "✓" : s.status === "running" ? "▶" : s.status === "failed" ? "✗" : s.status === "skipped" ? "⏭" : "○";
+        const result = s.result ? ` → ${s.result.slice(0, 50)}` : "";
+        lines.push(`  ${icon} ${i + 1}. ${s.action}: ${s.detail}${result}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=runbook-executor.js.map

package/dist/session-tail.d.ts

@@ -0,0 +1,24 @@
+export interface TailOptions {
+    sessionTitle: string;
+    lineCount: number;
+    highlightPattern?: string;
+    stripAnsi: boolean;
+}
+/**
+ * Extract the last N lines from session output, optionally highlighting matches.
+ */
+export declare function tailSession(output: string[], options: Partial<TailOptions> & {
+    sessionTitle: string;
+}): string[];
+/**
+ * Format tail output for TUI display.
+ */
+export declare function formatTail(sessionTitle: string, lines: string[], total: number): string[];
+/**
+ * Parse tail command arguments.
+ * Format: /tail <session> [count] [pattern]
+ */
+export declare function parseTailArgs(args: string): Partial<TailOptions> & {
+    sessionTitle: string;
+};
+//# sourceMappingURL=session-tail.d.ts.map

package/dist/session-tail.js

@@ -0,0 +1,52 @@
+// session-tail.ts — live tail of any session's output from the TUI.
+// provides a filtered view of a specific session's recent output lines
+// with optional pattern highlighting.
+const DEFAULT_OPTIONS = {
+    lineCount: 30,
+    stripAnsi: true,
+};
+/**
+ * Extract the last N lines from session output, optionally highlighting matches.
+ */
+export function tailSession(output, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lines = output.slice(-opts.lineCount);
+    if (opts.stripAnsi) {
+        lines = lines.map((l) => l.replace(/\x1b\[[0-9;]*[mABCDHJKST]/g, ""));
+    }
+    if (opts.highlightPattern) {
+        try {
+            const regex = new RegExp(opts.highlightPattern, "gi");
+            lines = lines.map((l) => l.replace(regex, (match) => `>>>${match}<<<`));
+        }
+        catch { /* invalid regex, skip highlighting */ }
+    }
+    return lines;
+}
+/**
+ * Format tail output for TUI display.
+ */
+export function formatTail(sessionTitle, lines, total) {
+    const header = `  tail: "${sessionTitle}" (last ${lines.length} of ${total} lines)`;
+    const sep = "  " + "─".repeat(70);
+    return [header, sep, ...lines.map((l) => `  ${l}`), sep];
+}
+/**
+ * Parse tail command arguments.
+ * Format: /tail <session> [count] [pattern]
+ */
+export function parseTailArgs(args) {
+    const parts = args.split(/\s+/);
+    const sessionTitle = parts[0];
+    let lineCount = 30;
+    let highlightPattern;
+    for (let i = 1; i < parts.length; i++) {
+        const num = parseInt(parts[i], 10);
+        if (!isNaN(num) && num > 0)
+            lineCount = num;
+        else
+            highlightPattern = parts[i];
+    }
+    return { sessionTitle, lineCount, highlightPattern };
+}
+//# sourceMappingURL=session-tail.js.map

package/dist/workflow-viz.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowState } from "./workflow-engine.js";
+import type { WorkflowChain } from "./workflow-chain.js";
+/**
+ * Render a workflow as an ASCII pipeline diagram.
+ */
+export declare function renderWorkflowDag(workflow: WorkflowState): string[];
+/**
+ * Render a workflow chain as an ASCII dependency DAG.
+ */
+export declare function renderChainDag(chain: WorkflowChain): string[];
+/**
+ * Render a compact workflow summary (single-line per stage).
+ */
+export declare function renderWorkflowCompact(workflow: WorkflowState): string;
+//# sourceMappingURL=workflow-viz.d.ts.map

package/dist/workflow-viz.js

@@ -0,0 +1,74 @@
+// workflow-viz.ts — ASCII DAG rendering for workflows and workflow chains.
+// produces a visual graph of stage/task dependencies with status icons.
+/**
+ * Render a workflow as an ASCII pipeline diagram.
+ */
+export function renderWorkflowDag(workflow) {
+    const lines = [];
+    lines.push(`  ┌─ Workflow: ${workflow.name} ─┐`);
+    for (let i = 0; i < workflow.stages.length; i++) {
+        const stage = workflow.stages[i];
+        const icon = stage.status === "completed" ? "✓" : stage.status === "active" ? "▶" : stage.status === "failed" ? "✗" : "○";
+        const current = i === workflow.currentStage ? " ◄" : "";
+        lines.push(`  │`);
+        lines.push(`  ├─[${icon}] ${stage.name}${current}`);
+        for (const task of stage.tasks) {
+            const tIcon = task.status === "completed" ? "✓" : task.status === "active" ? "~" : task.status === "failed" ? "!" : ".";
+            lines.push(`  │   └─[${tIcon}] ${task.sessionTitle}`);
+        }
+        if (i < workflow.stages.length - 1) {
+            lines.push(`  │   ↓`);
+        }
+    }
+    lines.push(`  └${"─".repeat(40)}┘`);
+    return lines;
+}
+/**
+ * Render a workflow chain as an ASCII dependency DAG.
+ */
+export function renderChainDag(chain) {
+    const lines = [];
+    lines.push(`  ╔═ Chain: ${chain.name} ═╗`);
+    // group by depth (entries with no deps = depth 0, etc.)
+    const depths = new Map();
+    const getDepth = (name, visited = new Set()) => {
+        if (depths.has(name))
+            return depths.get(name);
+        if (visited.has(name))
+            return 0;
+        visited.add(name);
+        const entry = chain.entries.find((e) => e.workflowName === name);
+        if (!entry || entry.dependsOn.length === 0) {
+            depths.set(name, 0);
+            return 0;
+        }
+        const maxDep = Math.max(...entry.dependsOn.map((d) => getDepth(d, visited)));
+        const depth = maxDep + 1;
+        depths.set(name, depth);
+        return depth;
+    };
+    for (const e of chain.entries)
+        getDepth(e.workflowName);
+    const maxDepth = Math.max(0, ...depths.values());
+    for (let d = 0; d <= maxDepth; d++) {
+        const atDepth = chain.entries.filter((e) => (depths.get(e.workflowName) ?? 0) === d);
+        if (d > 0)
+            lines.push(`  ║   ↓`);
+        const indent = "  ║" + "  ".repeat(d);
+        for (const e of atDepth) {
+            const icon = e.status === "completed" ? "✓" : e.status === "active" ? "▶" : e.status === "failed" ? "✗" : "○";
+            const deps = e.dependsOn.length > 0 ? ` ← ${e.dependsOn.join(",")}` : "";
+            lines.push(`${indent} [${icon}] ${e.workflowName}${deps}`);
+        }
+    }
+    lines.push(`  ╚${"═".repeat(40)}╝`);
+    return lines;
+}
+/**
+ * Render a compact workflow summary (single-line per stage).
+ */
+export function renderWorkflowCompact(workflow) {
+    const icons = workflow.stages.map((s) => s.status === "completed" ? "✓" : s.status === "active" ? "▶" : s.status === "failed" ? "✗" : "○");
+    return `[${icons.join("→")}] ${workflow.name}`;
+}
+//# sourceMappingURL=workflow-viz.js.map

package/package.json

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