aoaoe 1.3.0 → 2.5.0

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

@@ -61,7 +61,21 @@ 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 { 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";
@@ -567,6 +581,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 +2499,173 @@ 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);
+        });
+        // 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());
@@ -2928,6 +3127,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 +4226,7 @@ async function main() {
                         escalationManager,
                         graduationManager,
                         approvalQueue,
+                        tokenQuotaManager,
                         pushSupervisorEvent,
                         refreshTaskSupervisorState,
                     });
@@ -4111,6 +4332,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 +4508,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 +4594,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,20 @@ 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 type SessionTailHandler = (args: string) => void;
+export type HealthForecastHandler = () => void;
+export type WorkflowVizHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -452,6 +466,34 @@ 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;
+    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

@@ -546,6 +546,34 @@ export class InputReader {
     onService(handler) { this.serviceHandler = handler; }
     onSessionReplay(handler) { this.sessionReplayHandler = handler; }
     onWorkflow(handler) { this.workflowHandler = handler; }
+    multiReasonerHandler = null;
+    tokenQuotaHandler = null;
+    checkpointHandler = null;
+    workflowNewHandler = null;
+    onMultiReasoner(handler) { this.multiReasonerHandler = handler; }
+    onTokenQuota(handler) { this.tokenQuotaHandler = handler; }
+    onCheckpoint(handler) { this.checkpointHandler = handler; }
+    onWorkflowNew(handler) { this.workflowNewHandler = handler; }
+    abStatsHandler = null;
+    workflowChainHandler = null;
+    workflowForecastHandler = null;
+    onABStats(handler) { this.abStatsHandler = handler; }
+    onWorkflowChain(handler) { this.workflowChainHandler = handler; }
+    onWorkflowForecast(handler) { this.workflowForecastHandler = handler; }
+    federationHandler = null;
+    archivesHandler = null;
+    runbookGenHandler = null;
+    alertRulesHandler = null;
+    onFederation(handler) { this.federationHandler = handler; }
+    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; }
@@ -2394,6 +2422,108 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}workflow not available (no TUI)${RESET}`);
                 break;
+            case "/multi-reasoner":
+                if (this.multiReasonerHandler)
+                    this.multiReasonerHandler();
+                else
+                    console.error(`${DIM}multi-reasoner not available (no TUI)${RESET}`);
+                break;
+            case "/token-quota":
+                if (this.tokenQuotaHandler)
+                    this.tokenQuotaHandler();
+                else
+                    console.error(`${DIM}token-quota not available (no TUI)${RESET}`);
+                break;
+            case "/checkpoint":
+                if (this.checkpointHandler)
+                    this.checkpointHandler();
+                else
+                    console.error(`${DIM}checkpoint not available (no TUI)${RESET}`);
+                break;
+            case "/workflow-new": {
+                const wnArg = line.slice("/workflow-new".length).trim();
+                if (!wnArg) {
+                    console.error(`${DIM}usage: /workflow-new <template> <prefix>${RESET}`);
+                    break;
+                }
+                if (this.workflowNewHandler)
+                    this.workflowNewHandler(wnArg);
+                else
+                    console.error(`${DIM}workflow-new not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/ab-stats":
+                if (this.abStatsHandler)
+                    this.abStatsHandler();
+                else
+                    console.error(`${DIM}ab-stats not available (no TUI)${RESET}`);
+                break;
+            case "/workflow-chain":
+                if (this.workflowChainHandler)
+                    this.workflowChainHandler();
+                else
+                    console.error(`${DIM}workflow-chain not available (no TUI)${RESET}`);
+                break;
+            case "/workflow-forecast": {
+                const wfArg = line.slice("/workflow-forecast".length).trim();
+                if (!wfArg) {
+                    console.error(`${DIM}usage: /workflow-forecast <template>${RESET}`);
+                    break;
+                }
+                if (this.workflowForecastHandler)
+                    this.workflowForecastHandler(wfArg);
+                else
+                    console.error(`${DIM}workflow-forecast not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/federation":
+                if (this.federationHandler)
+                    this.federationHandler();
+                else
+                    console.error(`${DIM}federation not available (no TUI)${RESET}`);
+                break;
+            case "/archives":
+                if (this.archivesHandler)
+                    this.archivesHandler();
+                else
+                    console.error(`${DIM}archives not available (no TUI)${RESET}`);
+                break;
+            case "/runbook-gen":
+                if (this.runbookGenHandler)
+                    this.runbookGenHandler();
+                else
+                    console.error(`${DIM}runbook-gen not available (no TUI)${RESET}`);
+                break;
+            case "/alert-rules":
+                if (this.alertRulesHandler)
+                    this.alertRulesHandler();
+                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