aoaoe 1.0.0 → 2.0.0

package/dist/index.js

@@ -59,6 +59,20 @@ import { GraduationManager } from "./session-graduation.js";
 import { filterThroughApproval, formatApprovalWorkflowStatus } from "./approval-workflow.js";
 import { analyzeCompletedTasks, refineGoal, formatGoalRefinement } from "./goal-refiner.js";
 import { generateHtmlReport, buildReportData } from "./fleet-export.js";
+import { installService } from "./service-generator.js";
+import { buildSessionReplay, formatReplay, summarizeReplay } from "./session-replay.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";
@@ -87,7 +101,7 @@ const AOAOE_DIR = join(homedir(), ".aoaoe"); // watch dir for wakeable sleep
 const INPUT_FILE = join(AOAOE_DIR, "pending-input.txt"); // file IPC from chat.ts
 const TASK_RECONCILE_EVERY_POLLS = 6;
 async function main() {
-    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showTasksJson, runProgress, progressSince, progressJson, runHealth, healthJson, runSummary, runAdopt, adoptTemplate, showHistory, showStatus, runRunbook, runbookJson, runbookSection, runIncident, incidentSince, incidentLimit, incidentJson, incidentNdjson, incidentWatch, incidentChangesOnly, incidentHeartbeatSec, incidentIntervalMs, runSupervisor, supervisorAll, supervisorSince, supervisorLimit, supervisorJson, supervisorNdjson, supervisorWatch, supervisorChangesOnly, supervisorHeartbeatSec, supervisorIntervalMs, showConfig, configValidate, configDiff, notifyTest, runDoctor, runBackup, backupOutput, runRestore, restoreInput, runSync, syncAction, syncRemote, runWeb, webPort, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, runReplay: isReplay, replaySpeed, replayLast, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showTasksJson, runProgress, progressSince, progressJson, runHealth, healthJson, runSummary, runAdopt, adoptTemplate, showHistory, showStatus, runRunbook, runbookJson, runbookSection, runIncident, incidentSince, incidentLimit, incidentJson, incidentNdjson, incidentWatch, incidentChangesOnly, incidentHeartbeatSec, incidentIntervalMs, runSupervisor, supervisorAll, supervisorSince, supervisorLimit, supervisorJson, supervisorNdjson, supervisorWatch, supervisorChangesOnly, supervisorHeartbeatSec, supervisorIntervalMs, showConfig, configValidate, configDiff, notifyTest, runDoctor, runBackup, backupOutput, runRestore, restoreInput, runSync, syncAction, syncRemote, runWeb, webPort, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, runReplay: isReplay, replaySpeed, replayLast, registerTitle, runService, runCompletions, completionsShell } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -232,6 +246,18 @@ async function main() {
         await runDoctorCheck();
         return;
     }
+    if (runService) {
+        const lines = installService({ workingDir: process.cwd() });
+        for (const l of lines)
+            console.log(l);
+        return;
+    }
+    if (runCompletions) {
+        const { generateCompletion } = await import("./cli-completions.js");
+        const shell = (completionsShell ?? "bash");
+        console.log(generateCompletion(shell));
+        return;
+    }
     if (runBackup) {
         try {
             const result = await createBackup(backupOutput);
@@ -551,6 +577,25 @@ async function main() {
     const recoveryPlaybookManager = new RecoveryPlaybookManager();
     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) => {
@@ -2420,6 +2465,151 @@ async function main() {
             writeFileSync(filepath, html);
             tui.log("system", `fleet report exported: ${filepath}`);
         });
+        // wire /service — generate systemd/launchd service file
+        input.onService(() => {
+            const lines = installService({ workingDir: process.cwd() });
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /session-replay — session activity timeline replay
+        input.onSessionReplay((target) => {
+            const replay = buildSessionReplay(target);
+            if (replay.events.length === 0) {
+                tui.log("system", `replay: no events for "${target}" — run the daemon to generate audit data first`);
+                return;
+            }
+            const summary = summarizeReplay(replay);
+            for (const l of summary)
+                tui.log("system", l);
+            tui.log("system", "");
+            const detailed = formatReplay(replay);
+            for (const l of detailed)
+                tui.log("system", l);
+        });
+        // wire /workflow — show active workflow state
+        input.onWorkflow(() => {
+            if (!activeWorkflow) {
+                tui.log("system", "workflow: no active workflow (define one in aoaoe.tasks.json with workflow stages)");
+                return;
+            }
+            const lines = formatWorkflow(activeWorkflow);
+            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());
@@ -2881,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);
         });
@@ -3959,6 +4170,7 @@ async function main() {
                         escalationManager,
                         graduationManager,
                         approvalQueue,
+                        tokenQuotaManager,
                         pushSupervisorEvent,
                         refreshTaskSupervisorState,
                     });
@@ -4045,6 +4257,64 @@ async function main() {
                             }
                         }
                     }
+                    // workflow engine: advance active workflow based on task states
+                    if (activeWorkflow && taskManager && tui) {
+                        const wf = activeWorkflow; // capture before potential null assignment
+                        const taskStates = new Map(taskManager.tasks.map((t) => [t.sessionTitle, t.status]));
+                        const { actions: wfActions, completed } = advanceWorkflow(wf, taskStates);
+                        for (const a of wfActions) {
+                            if (a.type === "activate_task") {
+                                const task = taskManager.getTaskForSession(a.detail);
+                                if (task && task.status === "pending")
+                                    task.status = "active";
+                            }
+                            tui.log("status", `workflow: ${a.type} — ${a.detail}`);
+                            audit("task_created", `workflow ${a.type}: ${a.detail}`, a.detail);
+                        }
+                        if (completed) {
+                            tui.log("+ action", `workflow "${wf.name}" completed`);
+                            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) {
@@ -4182,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();
@@ -4260,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

@@ -131,6 +131,20 @@ export type AllocationHandler = () => void;
 export type GraduationHandler = () => void;
 export type RefineHandler = (target: string) => void;
 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;
@@ -443,6 +457,34 @@ export declare class InputReader {
     onGraduation(handler: GraduationHandler): void;
     onRefine(handler: RefineHandler): void;
     onExport(handler: ExportHandler): void;
+    private serviceHandler;
+    private sessionReplayHandler;
+    private workflowHandler;
+    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;

package/dist/input.js

@@ -540,6 +540,34 @@ export class InputReader {
     onGraduation(handler) { this.graduationHandler = handler; }
     onRefine(handler) { this.refineHandler = handler; }
     onExport(handler) { this.exportHandler = handler; }
+    serviceHandler = null;
+    sessionReplayHandler = null;
+    workflowHandler = null;
+    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; }
     onFleetSearch(handler) { this.fleetSearchHandler = handler; }
     onNudgeStats(handler) { this.nudgeStatsHandler = handler; }
     onAllocation(handler) { this.allocationHandler = handler; }
@@ -2364,6 +2392,108 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}export not available (no TUI)${RESET}`);
                 break;
+            case "/service":
+                if (this.serviceHandler)
+                    this.serviceHandler();
+                else
+                    console.error(`${DIM}service not available (no TUI)${RESET}`);
+                break;
+            case "/session-replay": {
+                const rpArg = line.slice("/session-replay".length).trim();
+                if (!rpArg) {
+                    console.error(`${DIM}usage: /session-replay <session-name>${RESET}`);
+                    break;
+                }
+                if (this.sessionReplayHandler)
+                    this.sessionReplayHandler(rpArg);
+                else
+                    console.error(`${DIM}session-replay not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/workflow":
+                if (this.workflowHandler)
+                    this.workflowHandler();
+                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 "/clear":
                 process.stderr.write("\x1b[2J\x1b[H");
                 break;

package/dist/multi-reasoner.d.ts

@@ -0,0 +1,36 @@
+import type { Observation, ReasonerResult } from "./types.js";
+export type ReasonerBackend = "opencode" | "claude-code" | "gemini" | "custom";
+export interface ReasonerAssignment {
+    sessionTitle: string;
+    backend: ReasonerBackend;
+    reason: string;
+}
+export interface MultiReasonerConfig {
+    defaultBackend: ReasonerBackend;
+    sessionOverrides: Record<string, ReasonerBackend>;
+    templateMappings: Record<string, ReasonerBackend>;
+    difficultyThreshold: number;
+    premiumBackend: ReasonerBackend;
+    economyBackend: ReasonerBackend;
+}
+/**
+ * Determine which reasoner backend to use for each session.
+ */
+export declare function assignReasonerBackends(sessions: Array<{
+    title: string;
+    template?: string;
+    difficultyScore?: number;
+}>, config?: Partial<MultiReasonerConfig>): ReasonerAssignment[];
+/**
+ * Split an observation into per-backend groups for routing.
+ */
+export declare function routeObservation(observation: Observation, assignments: ReasonerAssignment[]): Map<ReasonerBackend, Observation>;
+/**
+ * Merge results from multiple reasoner backends into a single result.
+ */
+export declare function mergeReasonerResults(results: ReasonerResult[]): ReasonerResult;
+/**
+ * Format assignments for TUI display.
+ */
+export declare function formatAssignments(assignments: ReasonerAssignment[]): string[];
+//# sourceMappingURL=multi-reasoner.d.ts.map