aoaoe 1.3.0 → 2.5.0

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-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/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/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

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