aoaoe 1.3.0 → 2.0.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-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/index.js

@@ -61,7 +61,18 @@ import { analyzeCompletedTasks, refineGoal, formatGoalRefinement } from "./goal-
 import { generateHtmlReport, buildReportData } from "./fleet-export.js";
 import { installService } from "./service-generator.js";
 import { buildSessionReplay, formatReplay, summarizeReplay } from "./session-replay.js";
-import { advanceWorkflow, formatWorkflow } from "./workflow-engine.js";
+import { createWorkflowState, advanceWorkflow, formatWorkflow } from "./workflow-engine.js";
+import { assignReasonerBackends, formatAssignments } from "./multi-reasoner.js";
+import { TokenQuotaManager } from "./token-quota.js";
+import { saveCheckpoint, loadCheckpoint, buildCheckpoint, formatCheckpointInfo, shouldRestoreCheckpoint } from "./session-checkpoint.js";
+import { findWorkflowTemplate, instantiateWorkflow, formatWorkflowTemplateList } from "./workflow-templates.js";
+import { ABReasoningTracker } from "./ab-reasoning.js";
+import { forecastWorkflowCost, formatWorkflowCostForecast } from "./workflow-cost-forecast.js";
+import { advanceChain, formatWorkflowChain } from "./workflow-chain.js";
+import { aggregateFederation, formatFederationOverview } from "./fleet-federation.js";
+import { formatArchiveList } from "./output-archival.js";
+import { generateRunbooks, formatGeneratedRunbooks } from "./runbook-generator.js";
+import { defaultAlertRules, evaluateAlertRules, formatAlertRules } from "./alert-rules.js";
 import { buildLifecycleRecords, computeLifecycleStats, formatLifecycleStats } from "./lifecycle-analytics.js";
 import { buildCostAttributions, computeCostReport, formatCostReport } from "./cost-attribution.js";
 import { decomposeGoal, formatDecomposition } from "./goal-decomposer.js";
@@ -567,6 +578,24 @@ async function main() {
     const approvalQueue = new ApprovalQueue();
     const graduationManager = new GraduationManager();
     let activeWorkflow = null;
+    let activeWorkflowChain = null;
+    const tokenQuotaManager = new TokenQuotaManager();
+    const abReasoningTracker = new ABReasoningTracker(config.reasoner, "claude-code");
+    const alertRules = defaultAlertRules();
+    // checkpoint restore: load previous daemon state if available
+    if (shouldRestoreCheckpoint()) {
+        const cp = loadCheckpoint();
+        if (cp) {
+            // restore adaptive poll interval
+            if (cp.pollInterval && cp.pollInterval !== config.pollIntervalMs) {
+                // poll controller will naturally adjust, but log what was saved
+            }
+            const restoredSessions = Object.keys(cp.graduation).length;
+            if (restoredSessions > 0) {
+                audit("daemon_start", `restored checkpoint: ${restoredSessions} graduation states, cache ${cp.cacheStats.hits}/${cp.cacheStats.misses}`);
+            }
+        }
+    }
     // audit: log daemon start
     audit("daemon_start", `daemon started (v${pkg ?? "dev"}, reasoner=${config.reasoner})`);
     const refreshTaskSupervisorState = (reason) => {
@@ -2467,6 +2496,120 @@ async function main() {
             for (const l of lines)
                 tui.log("system", l);
         });
+        // wire /multi-reasoner — show reasoner assignments
+        input.onMultiReasoner(() => {
+            const sessions = tui.getSessions();
+            const sessionInfos = sessions.map((s) => ({ title: s.title, template: undefined, difficultyScore: undefined }));
+            const assignments = assignReasonerBackends(sessionInfos, { defaultBackend: config.reasoner });
+            const lines = formatAssignments(assignments);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /token-quota — per-model token quotas
+        input.onTokenQuota(() => {
+            const lines = tokenQuotaManager.formatAll();
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /checkpoint — show checkpoint info
+        input.onCheckpoint(() => {
+            const lines = formatCheckpointInfo();
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /workflow-new — create workflow from template
+        input.onWorkflowNew((args) => {
+            const parts = args.split(/\s+/);
+            const templateName = parts[0];
+            const prefix = parts[1] ?? "wf";
+            const template = findWorkflowTemplate(templateName);
+            if (!template) {
+                tui.log("system", `workflow-new: template "${templateName}" not found`);
+                const lines = formatWorkflowTemplateList();
+                for (const l of lines)
+                    tui.log("system", l);
+                return;
+            }
+            const def = instantiateWorkflow(template, prefix);
+            // show cost forecast before creating
+            const forecast = forecastWorkflowCost(def);
+            const forecastLines = formatWorkflowCostForecast(forecast);
+            for (const l of forecastLines)
+                tui.log("system", l);
+            activeWorkflow = createWorkflowState(def);
+            tui.log("+ action", `workflow "${def.name}" created from template "${templateName}" (${def.stages.length} stages)`);
+            audit("task_created", `workflow created: ${def.name} from ${templateName}`, undefined, { stages: def.stages.length });
+            const lines = formatWorkflow(activeWorkflow);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /ab-stats — A/B reasoning statistics
+        input.onABStats(() => {
+            const lines = abReasoningTracker.formatStats();
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /workflow-chain — show active workflow chain
+        input.onWorkflowChain(() => {
+            if (!activeWorkflowChain) {
+                tui.log("system", "workflow-chain: no active chain");
+                return;
+            }
+            const lines = formatWorkflowChain(activeWorkflowChain);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /workflow-forecast — preview cost estimate for a template
+        input.onWorkflowForecast((templateName) => {
+            const template = findWorkflowTemplate(templateName);
+            if (!template) {
+                tui.log("system", `workflow-forecast: template "${templateName}" not found`);
+                return;
+            }
+            const def = instantiateWorkflow(template, "preview");
+            const forecast = forecastWorkflowCost(def);
+            const lines = formatWorkflowCostForecast(forecast);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /federation — multi-host fleet overview
+        input.onFederation(() => {
+            // in practice, would fetch from configured peers; show local state as single peer
+            const sessions = tui.getSessions();
+            const tasks = taskManager?.tasks ?? [];
+            const scores = sessions.map((s) => s.status === "working" || s.status === "running" ? 80 : s.status === "error" ? 20 : 50);
+            const health = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 100;
+            let cost = 0;
+            for (const s of sessions) {
+                const m = s.costStr?.match(/\$(\d+(?:\.\d+)?)/);
+                if (m)
+                    cost += parseFloat(m[1]);
+            }
+            const localState = { peer: "local", sessions: sessions.length, activeTasks: tasks.filter((t) => t.status === "active").length, fleetHealth: health, totalCostUsd: cost, lastUpdatedAt: Date.now() };
+            const overview = aggregateFederation([localState]);
+            const lines = formatFederationOverview(overview);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /archives — show output archive list
+        input.onArchives(() => {
+            const lines = formatArchiveList();
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /runbook-gen — generate runbooks from audit trail
+        input.onRunbookGen(() => {
+            const runbooks = generateRunbooks();
+            const lines = formatGeneratedRunbooks(runbooks);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /alert-rules — show alert rules and their status
+        input.onAlertRules(() => {
+            const lines = formatAlertRules(alertRules);
+            for (const l of lines)
+                tui.log("system", l);
+        });
         input.onCostSummary(() => {
             const sessions = tui.getSessions();
             const summary = computeCostSummary(sessions, tui.getAllSessionCosts());
@@ -2928,6 +3071,27 @@ async function main() {
             .then(() => reasoner?.shutdown())
             .catch((err) => console.error(`[shutdown] error during cleanup: ${err}`))
             .finally(() => {
+            // save daemon state checkpoint before exit
+            try {
+                const cp = buildCheckpoint({
+                    graduation: Object.fromEntries([...(tui?.getSessions() ?? [])].map((s) => [s.title, {
+                            mode: graduationManager.getState(s.title)?.currentMode ?? "confirm",
+                            successes: graduationManager.getState(s.title)?.successfulActions ?? 0,
+                            failures: graduationManager.getState(s.title)?.failedActions ?? 0,
+                            rate: graduationManager.getState(s.title)?.successRate ?? 0,
+                        }])),
+                    escalation: {},
+                    velocitySamples: {},
+                    nudgeRecords: [],
+                    budgetSamples: {},
+                    cacheStats: { hits: observationCache.getStats().totalHits, misses: observationCache.getStats().totalMisses },
+                    slaHistory: [],
+                    pollInterval: adaptivePollController.intervalMs,
+                });
+                saveCheckpoint(cp);
+                audit("daemon_stop", "daemon stopped, checkpoint saved");
+            }
+            catch { /* best-effort */ }
             cleanupState();
             process.exit(0);
         });
@@ -4006,6 +4170,7 @@ async function main() {
                         escalationManager,
                         graduationManager,
                         approvalQueue,
+                        tokenQuotaManager,
                         pushSupervisorEvent,
                         refreshTaskSupervisorState,
                     });
@@ -4111,6 +4276,45 @@ async function main() {
                             activeWorkflow = null;
                         }
                     }
+                    // workflow chain: advance cross-workflow dependencies
+                    if (activeWorkflowChain && tui) {
+                        const chain = activeWorkflowChain;
+                        const wfStates = new Map();
+                        const { activate, completed: chainDone, failed: chainFailed } = advanceChain(chain, wfStates);
+                        for (const name of activate) {
+                            tui.log("status", `workflow-chain: activating workflow "${name}"`);
+                            audit("task_created", `chain activated: ${name}`, name);
+                        }
+                        if (chainDone) {
+                            tui.log("+ action", `workflow chain "${chain.name}" completed`);
+                            activeWorkflowChain = null;
+                        }
+                        if (chainFailed) {
+                            tui.log("status", `workflow chain "${chain.name}" has failures`);
+                        }
+                    }
+                    // custom alert rules: evaluate fleet conditions per tick
+                    if (tui) {
+                        const sessions = tui.getSessions();
+                        const tasks = taskManager?.tasks ?? [];
+                        const scores = sessions.map((s) => s.status === "working" || s.status === "running" ? 80 : s.status === "error" ? 20 : 50);
+                        const fleetHealth = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 100;
+                        const activeSessions = sessions.filter((s) => s.status === "working" || s.status === "running").length;
+                        const errorSessions = sessions.filter((s) => s.status === "error").length;
+                        const stuckSessions = tasks.filter((t) => t.status === "active" && (t.stuckNudgeCount ?? 0) > 0).length;
+                        let hourlyCost = 0;
+                        for (const s of sessions) {
+                            const m = s.costStr?.match(/\$(\d+(?:\.\d+)?)/);
+                            if (m)
+                                hourlyCost += parseFloat(m[1]);
+                        }
+                        const alertCtx = { fleetHealth, activeSessions, errorSessions, totalCostUsd: hourlyCost, hourlyCostRate: hourlyCost, stuckSessions, idleMinutes: new Map() };
+                        const firedAlerts = evaluateAlertRules(alertRules, alertCtx);
+                        for (const alert of firedAlerts) {
+                            tui.log("status", `${alert.severity === "critical" ? "🚨" : alert.severity === "warning" ? "⚠" : "ℹ"} ALERT: ${alert.message}`);
+                            audit("session_error", `alert fired: ${alert.ruleName} — ${alert.message}`, undefined, { severity: alert.severity });
+                        }
+                    }
                     // trust ladder: record stable tick or failure, sync mode if escalated
                     if (tui && decisionsThisTick > 0) {
                         if (actionsFail > 0) {
@@ -4248,6 +4452,14 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
         init: () => reasoner.init(),
         shutdown: () => reasoner.shutdown(),
         decide: async (obs) => {
+            // ── gate 0: per-model token quota — block if model quota exceeded ──
+            if (intelligence?.tokenQuotaManager.isBlocked(config.reasoner)) {
+                const status = intelligence.tokenQuotaManager.getStatus(config.reasoner);
+                if (tui)
+                    tui.log("status", `⏸ token quota exceeded for ${config.reasoner}: ${status.reason}`);
+                audit("reasoner_action", `token quota blocked: ${config.reasoner} — ${status.reason}`);
+                return { actions: [{ action: "wait", reason: `token quota: ${status.reason}` }] };
+            }
             // ── gate 1: fleet rate limiter — block if over API spend limits ──
             if (intelligence?.fleetRateLimiter.isBlocked()) {
                 const status = intelligence.fleetRateLimiter.getStatus();
@@ -4326,6 +4538,8 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
                 intelligence.reasonerCostTracker.recordCall("fleet", tokenEstimate, outputEstimate, reasonerDurationMs);
                 intelligence.fleetRateLimiter.recordCost(estimateCallCost(tokenEstimate, outputEstimate));
                 intelligence.observationCache.set(obsJson, r);
+                // per-model token quota tracking
+                intelligence.tokenQuotaManager.recordUsage(config.reasoner, tokenEstimate, outputEstimate);
                 // approval workflow: gate risky/low-confidence actions through approval queue
                 if (config.confirm || r.confidence === "low") {
                     const { immediate, queued } = filterThroughApproval(r, intelligence.approvalQueue);

package/dist/input.d.ts

@@ -134,6 +134,17 @@ export type ExportHandler = () => void;
 export type ServiceHandler = () => void;
 export type SessionReplayHandler = (target: string) => void;
 export type WorkflowHandler = () => void;
+export type MultiReasonerHandler = () => void;
+export type TokenQuotaHandler = () => void;
+export type CheckpointHandler = () => void;
+export type WorkflowNewHandler = (template: string) => void;
+export type ABStatsHandler = () => void;
+export type WorkflowChainHandler = () => void;
+export type WorkflowForecastHandler = (template: string) => void;
+export type FederationHandler = () => void;
+export type ArchivesHandler = () => void;
+export type RunbookGenHandler = () => void;
+export type AlertRulesHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -452,6 +463,28 @@ export declare class InputReader {
     onService(handler: ServiceHandler): void;
     onSessionReplay(handler: SessionReplayHandler): void;
     onWorkflow(handler: WorkflowHandler): void;
+    private multiReasonerHandler;
+    private tokenQuotaHandler;
+    private checkpointHandler;
+    private workflowNewHandler;
+    onMultiReasoner(handler: MultiReasonerHandler): void;
+    onTokenQuota(handler: TokenQuotaHandler): void;
+    onCheckpoint(handler: CheckpointHandler): void;
+    onWorkflowNew(handler: WorkflowNewHandler): void;
+    private abStatsHandler;
+    private workflowChainHandler;
+    private workflowForecastHandler;
+    onABStats(handler: ABStatsHandler): void;
+    onWorkflowChain(handler: WorkflowChainHandler): void;
+    onWorkflowForecast(handler: WorkflowForecastHandler): void;
+    private federationHandler;
+    private archivesHandler;
+    private runbookGenHandler;
+    private alertRulesHandler;
+    onFederation(handler: FederationHandler): void;
+    onArchives(handler: ArchivesHandler): void;
+    onRunbookGen(handler: RunbookGenHandler): void;
+    onAlertRules(handler: AlertRulesHandler): void;
     onFleetSearch(handler: FleetSearchHandler): void;
     onNudgeStats(handler: NudgeStatsHandler): void;
     onAllocation(handler: AllocationHandler): void;