aoaoe 0.195.0 → 1.3.0

package/README.md

@@ -4,7 +4,7 @@
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml"><img src="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
     <a href="https://www.npmjs.com/package/aoaoe"><img src="https://img.shields.io/npm/v/aoaoe" alt="npm version"></a>
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/releases"><img src="https://img.shields.io/github/v/release/Talador12/agent-of-agent-of-empires" alt="GitHub release"></a>
-    <img src="https://img.shields.io/badge/tests-2427-brightgreen" alt="tests">
+    <img src="https://img.shields.io/badge/tests-3332-brightgreen" alt="tests">
     <img src="https://img.shields.io/badge/node-%3E%3D20-blue" alt="Node.js >= 20">
     <img src="https://img.shields.io/badge/runtime%20deps-0-brightgreen" alt="zero runtime dependencies">
     <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
@@ -822,6 +822,28 @@ The daemon and chat UI communicate via files in `~/.aoaoe/`:
 | `chat.pid` | chat UI | daemon | Chat process PID for detection |
 | `actions.log` | daemon | -- | Persistent action history (JSONL) |
 
+## Intelligence Modules
+
+aoaoe includes 55 intelligence modules that run every daemon tick without LLM calls. They handle observability, automation, and fleet management autonomously:
+
+**Reasoning Pipeline** (7 gates, runs before every LLM call):
+- Fleet rate limiter, observation cache, priority filter, context compressor, LLM call, approval workflow, cost tracker
+
+**Per-Tick Autonomous Systems**:
+- Session summarizer, conflict detector + auto-resolver, goal completion detector, cost budget enforcer
+- Activity heatmap, budget predictor, task retry with backoff, adaptive poll controller
+- Fleet SLA monitor, progress velocity tracker, recovery playbook, dependency scheduler
+- Session graduation (trust ladder), fleet utilization tracker, anomaly detector
+- Workflow engine (fan-out/fan-in stage orchestration)
+
+**On-Demand Analytics** (via TUI commands):
+- Audit trail + search, fleet snapshots + diff, lifecycle analytics, cost attribution
+- Goal decomposition, difficulty scoring, smart nudge generation, template auto-detection
+- Fleet-wide search, nudge effectiveness tracking, difficulty-based allocation
+- Goal refinement from completed task patterns, fleet HTML export, session replay
+
+See `AGENTS.md` for the full source layout with all 55 modules described.
+
 ## Project Structure
 
 ```

package/dist/activity-heatmap.d.ts

@@ -0,0 +1,42 @@
+export interface ActivityBucket {
+    startMs: number;
+    count: number;
+}
+export interface SessionHeatmap {
+    sessionTitle: string;
+    buckets: ActivityBucket[];
+    sparkline: string;
+    totalEvents: number;
+    peakRate: number;
+}
+/**
+ * Render a sparkline string from an array of values.
+ * Values are normalized to 0-8 range based on the max value.
+ */
+export declare function renderSparkline(values: number[]): string;
+/**
+ * Track activity events per session in time buckets.
+ * Each tick, call `recordEvent()` for sessions with new output.
+ * Call `getHeatmap()` to render the sparkline for display.
+ */
+export declare class ActivityTracker {
+    private events;
+    private bucketMs;
+    private windowMs;
+    private bucketCount;
+    constructor(bucketMs?: number, bucketCount?: number);
+    /** Record an activity event for a session. */
+    recordEvent(sessionTitle: string, now?: number): void;
+    /** Get the heatmap for a single session. */
+    getHeatmap(sessionTitle: string, now?: number): SessionHeatmap;
+    /** Get heatmaps for all tracked sessions. */
+    getAllHeatmaps(now?: number): SessionHeatmap[];
+    /** Format a heatmap for TUI display. */
+    static format(heatmap: SessionHeatmap): string;
+    /** Format all heatmaps for TUI display. */
+    formatAll(now?: number): string[];
+    /** Get the number of tracked sessions (for testing). */
+    get sessionCount(): number;
+    private prune;
+}
+//# sourceMappingURL=activity-heatmap.d.ts.map

package/dist/activity-heatmap.js

@@ -0,0 +1,112 @@
+// activity-heatmap.ts — per-session activity sparkline for TUI display.
+// tracks change events per session in fixed-width time buckets and renders
+// as a compact sparkline using Unicode block characters.
+// sparkline characters: ▁▂▃▄▅▆▇█ (8 levels)
+const SPARK_CHARS = " ▁▂▃▄▅▆▇";
+/**
+ * Render a sparkline string from an array of values.
+ * Values are normalized to 0-8 range based on the max value.
+ */
+export function renderSparkline(values) {
+    if (values.length === 0)
+        return "";
+    const max = Math.max(...values);
+    if (max === 0)
+        return " ".repeat(values.length);
+    return values.map((v) => {
+        const idx = Math.round((v / max) * (SPARK_CHARS.length - 1));
+        return SPARK_CHARS[idx];
+    }).join("");
+}
+/**
+ * Track activity events per session in time buckets.
+ * Each tick, call `recordEvent()` for sessions with new output.
+ * Call `getHeatmap()` to render the sparkline for display.
+ */
+export class ActivityTracker {
+    events = new Map(); // session -> timestamps
+    bucketMs;
+    windowMs;
+    bucketCount;
+    constructor(bucketMs = 60_000, bucketCount = 30) {
+        this.bucketMs = bucketMs;
+        this.bucketCount = bucketCount;
+        this.windowMs = bucketMs * bucketCount;
+    }
+    /** Record an activity event for a session. */
+    recordEvent(sessionTitle, now = Date.now()) {
+        if (!this.events.has(sessionTitle))
+            this.events.set(sessionTitle, []);
+        this.events.get(sessionTitle).push(now);
+        this.prune(sessionTitle, now);
+    }
+    /** Get the heatmap for a single session. */
+    getHeatmap(sessionTitle, now = Date.now()) {
+        const timestamps = this.events.get(sessionTitle) ?? [];
+        const windowStart = now - this.windowMs;
+        // build buckets
+        const buckets = [];
+        for (let i = 0; i < this.bucketCount; i++) {
+            const startMs = windowStart + i * this.bucketMs;
+            const endMs = startMs + this.bucketMs;
+            // last bucket uses <= to include events at exactly `now`
+            const count = timestamps.filter((t) => t >= startMs && (i === this.bucketCount - 1 ? t <= endMs : t < endMs)).length;
+            buckets.push({ startMs, count });
+        }
+        const counts = buckets.map((b) => b.count);
+        const totalEvents = counts.reduce((a, b) => a + b, 0);
+        const peakRate = Math.max(...counts);
+        return {
+            sessionTitle,
+            buckets,
+            sparkline: renderSparkline(counts),
+            totalEvents,
+            peakRate,
+        };
+    }
+    /** Get heatmaps for all tracked sessions. */
+    getAllHeatmaps(now = Date.now()) {
+        const result = [];
+        for (const title of this.events.keys()) {
+            result.push(this.getHeatmap(title, now));
+        }
+        return result;
+    }
+    /** Format a heatmap for TUI display. */
+    static format(heatmap) {
+        const title = heatmap.sessionTitle.length > 18
+            ? heatmap.sessionTitle.slice(0, 15) + "..."
+            : heatmap.sessionTitle.padEnd(18);
+        const events = `${heatmap.totalEvents}ev`.padStart(5);
+        const peak = heatmap.peakRate > 0 ? ` peak:${heatmap.peakRate}/min` : "";
+        return `  ${title} ${heatmap.sparkline} ${events}${peak}`;
+    }
+    /** Format all heatmaps for TUI display. */
+    formatAll(now = Date.now()) {
+        const heatmaps = this.getAllHeatmaps(now);
+        if (heatmaps.length === 0)
+            return ["  (no activity data yet)"];
+        const lines = [];
+        lines.push(`  Activity heatmap (last ${this.bucketCount}min, 1min buckets):`);
+        for (const h of heatmaps) {
+            lines.push(ActivityTracker.format(h));
+        }
+        return lines;
+    }
+    /** Get the number of tracked sessions (for testing). */
+    get sessionCount() {
+        return this.events.size;
+    }
+    prune(sessionTitle, now) {
+        const cutoff = now - this.windowMs;
+        const timestamps = this.events.get(sessionTitle);
+        if (timestamps) {
+            const pruned = timestamps.filter((t) => t >= cutoff);
+            if (pruned.length === 0)
+                this.events.delete(sessionTitle);
+            else
+                this.events.set(sessionTitle, pruned);
+        }
+    }
+}
+//# sourceMappingURL=activity-heatmap.js.map

package/dist/adaptive-poll.d.ts

@@ -0,0 +1,31 @@
+export interface AdaptivePollConfig {
+    minIntervalMs: number;
+    maxIntervalMs: number;
+    baseIntervalMs: number;
+    rampUpFactor: number;
+    rampDownFactor: number;
+}
+/**
+ * Track session activity and compute adaptive poll intervals.
+ * Call `recordTick()` after each daemonTick with the number of changes observed.
+ */
+export declare class AdaptivePollController {
+    private config;
+    private currentIntervalMs;
+    private consecutiveIdleTicks;
+    private consecutiveActiveTicks;
+    constructor(config?: Partial<AdaptivePollConfig>);
+    /**
+     * Record the result of a tick and update the interval.
+     * @param changeCount - number of session changes in this tick
+     * @param hadReasonerAction - whether the reasoner took an action
+     */
+    recordTick(changeCount: number, hadReasonerAction: boolean): void;
+    /** Get the current adaptive poll interval. */
+    get intervalMs(): number;
+    /** Reset to base interval (e.g., on operator input). */
+    reset(): void;
+    /** Get a human-readable status string. */
+    formatStatus(): string;
+}
+//# sourceMappingURL=adaptive-poll.d.ts.map

package/dist/adaptive-poll.js

@@ -0,0 +1,64 @@
+// adaptive-poll.ts — dynamic poll interval: speed up when sessions are active,
+// slow down when everything is idle. avoids wasting CPU/API on sleeping sessions
+// while staying responsive when work is happening.
+const DEFAULT_CONFIG = {
+    minIntervalMs: 5_000,
+    maxIntervalMs: 60_000,
+    baseIntervalMs: 10_000,
+    rampUpFactor: 1.5,
+    rampDownFactor: 2,
+};
+/**
+ * Track session activity and compute adaptive poll intervals.
+ * Call `recordTick()` after each daemonTick with the number of changes observed.
+ */
+export class AdaptivePollController {
+    config;
+    currentIntervalMs;
+    consecutiveIdleTicks = 0;
+    consecutiveActiveTicks = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.currentIntervalMs = this.config.baseIntervalMs;
+    }
+    /**
+     * Record the result of a tick and update the interval.
+     * @param changeCount - number of session changes in this tick
+     * @param hadReasonerAction - whether the reasoner took an action
+     */
+    recordTick(changeCount, hadReasonerAction) {
+        const active = changeCount > 0 || hadReasonerAction;
+        if (active) {
+            this.consecutiveActiveTicks++;
+            this.consecutiveIdleTicks = 0;
+            // ramp down (speed up) when active
+            if (this.consecutiveActiveTicks >= 2) {
+                this.currentIntervalMs = Math.max(this.config.minIntervalMs, Math.round(this.currentIntervalMs / this.config.rampDownFactor));
+            }
+        }
+        else {
+            this.consecutiveIdleTicks++;
+            this.consecutiveActiveTicks = 0;
+            // ramp up (slow down) when idle — but only after 3+ idle ticks
+            if (this.consecutiveIdleTicks >= 3) {
+                this.currentIntervalMs = Math.min(this.config.maxIntervalMs, Math.round(this.currentIntervalMs * this.config.rampUpFactor));
+            }
+        }
+    }
+    /** Get the current adaptive poll interval. */
+    get intervalMs() {
+        return this.currentIntervalMs;
+    }
+    /** Reset to base interval (e.g., on operator input). */
+    reset() {
+        this.currentIntervalMs = this.config.baseIntervalMs;
+        this.consecutiveIdleTicks = 0;
+        this.consecutiveActiveTicks = 0;
+    }
+    /** Get a human-readable status string. */
+    formatStatus() {
+        const mode = this.consecutiveActiveTicks >= 2 ? "fast" : this.consecutiveIdleTicks >= 3 ? "slow" : "normal";
+        return `poll: ${(this.currentIntervalMs / 1000).toFixed(1)}s (${mode}, idle=${this.consecutiveIdleTicks}, active=${this.consecutiveActiveTicks})`;
+    }
+}
+//# sourceMappingURL=adaptive-poll.js.map

package/dist/anomaly-detector.d.ts

@@ -0,0 +1,38 @@
+export interface AnomalySignal {
+    sessionTitle: string;
+    metric: "cost_rate" | "activity_rate" | "error_rate" | "idle_duration";
+    value: number;
+    fleetMean: number;
+    fleetStdDev: number;
+    zScore: number;
+    anomalous: boolean;
+    detail: string;
+}
+/**
+ * Compute mean and standard deviation for an array of numbers.
+ */
+export declare function computeStats(values: number[]): {
+    mean: number;
+    stdDev: number;
+};
+/**
+ * Compute z-score: how many standard deviations from the mean.
+ */
+export declare function zScore(value: number, mean: number, stdDev: number): number;
+export interface SessionMetrics {
+    sessionTitle: string;
+    costRatePerHour: number;
+    activityEventsPerHour: number;
+    errorCount: number;
+    idleDurationMs: number;
+}
+/**
+ * Detect anomalies across fleet sessions.
+ * A session is anomalous if any metric has |z-score| > threshold.
+ */
+export declare function detectAnomalies(sessions: SessionMetrics[], threshold?: number): AnomalySignal[];
+/**
+ * Format anomaly signals for TUI display.
+ */
+export declare function formatAnomalies(signals: AnomalySignal[]): string[];
+//# sourceMappingURL=anomaly-detector.d.ts.map

package/dist/anomaly-detector.js

@@ -0,0 +1,77 @@
+// anomaly-detector.ts — flag sessions with unusual cost or activity patterns.
+// uses z-score against fleet-wide statistics to identify outliers.
+/**
+ * Compute mean and standard deviation for an array of numbers.
+ */
+export function computeStats(values) {
+    if (values.length === 0)
+        return { mean: 0, stdDev: 0 };
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    if (values.length === 1)
+        return { mean, stdDev: 0 };
+    const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+    return { mean, stdDev: Math.sqrt(variance) };
+}
+/**
+ * Compute z-score: how many standard deviations from the mean.
+ */
+export function zScore(value, mean, stdDev) {
+    if (stdDev === 0)
+        return 0;
+    return (value - mean) / stdDev;
+}
+/**
+ * Detect anomalies across fleet sessions.
+ * A session is anomalous if any metric has |z-score| > threshold.
+ */
+export function detectAnomalies(sessions, threshold = 2.0) {
+    if (sessions.length < 3)
+        return []; // need 3+ for meaningful statistics
+    const signals = [];
+    // check each metric across fleet
+    const metrics = [
+        { key: "costRatePerHour", metric: "cost_rate", highIsAnomaly: true },
+        { key: "activityEventsPerHour", metric: "activity_rate", highIsAnomaly: false }, // both high and low
+        { key: "errorCount", metric: "error_rate", highIsAnomaly: true },
+        { key: "idleDurationMs", metric: "idle_duration", highIsAnomaly: true },
+    ];
+    for (const { key, metric, highIsAnomaly } of metrics) {
+        const values = sessions.map((s) => s[key]);
+        const { mean, stdDev } = computeStats(values);
+        if (stdDev === 0)
+            continue; // all same value, no anomaly possible
+        for (const session of sessions) {
+            const value = session[key];
+            const z = zScore(value, mean, stdDev);
+            const anomalous = highIsAnomaly ? z > threshold : Math.abs(z) > threshold;
+            if (anomalous) {
+                const direction = z > 0 ? "above" : "below";
+                signals.push({
+                    sessionTitle: session.sessionTitle,
+                    metric,
+                    value,
+                    fleetMean: mean,
+                    fleetStdDev: stdDev,
+                    zScore: z,
+                    anomalous: true,
+                    detail: `${metric}: ${value.toFixed(2)} is ${Math.abs(z).toFixed(1)}σ ${direction} fleet mean (${mean.toFixed(2)})`,
+                });
+            }
+        }
+    }
+    return signals;
+}
+/**
+ * Format anomaly signals for TUI display.
+ */
+export function formatAnomalies(signals) {
+    if (signals.length === 0)
+        return ["  ✅ no anomalies detected"];
+    const lines = [];
+    lines.push(`  ⚠ ${signals.length} anomal${signals.length !== 1 ? "ies" : "y"} detected:`);
+    for (const s of signals) {
+        lines.push(`  ${s.sessionTitle}: ${s.detail}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=anomaly-detector.js.map

package/dist/approval-queue.d.ts

@@ -0,0 +1,47 @@
+export interface PendingApproval {
+    id: string;
+    timestamp: number;
+    sessionTitle: string;
+    actionType: string;
+    detail: string;
+    confidence: "high" | "medium" | "low";
+    status: "pending" | "approved" | "rejected" | "expired";
+}
+export interface ApprovalQueueConfig {
+    maxPending: number;
+    expiryMs: number;
+}
+/**
+ * Manage an operator approval queue for daemon decisions.
+ */
+export declare class ApprovalQueue {
+    private items;
+    private config;
+    constructor(config?: Partial<ApprovalQueueConfig>);
+    /** Queue a decision for approval. Returns the approval ID. */
+    enqueue(sessionTitle: string, actionType: string, detail: string, confidence?: PendingApproval["confidence"], now?: number): string;
+    /** Approve a queued decision by ID. */
+    approve(id: string): boolean;
+    /** Reject a queued decision by ID. */
+    reject(id: string): boolean;
+    /** Approve all pending items. Returns count approved. */
+    approveAll(): number;
+    /** Reject all pending items. Returns count rejected. */
+    rejectAll(): number;
+    /** Get all pending items. */
+    getPending(now?: number): PendingApproval[];
+    /** Get approved items that haven't been consumed yet. */
+    consumeApproved(): PendingApproval[];
+    /** Get queue statistics. */
+    getStats(): {
+        pending: number;
+        approved: number;
+        rejected: number;
+        expired: number;
+        total: number;
+    };
+    /** Format queue for TUI display. */
+    formatQueue(now?: number): string[];
+    private expire;
+}
+//# sourceMappingURL=approval-queue.d.ts.map

package/dist/approval-queue.js

@@ -0,0 +1,113 @@
+// approval-queue.ts — batch pending decisions for async human review.
+// when the daemon is in confirm mode or has low-confidence decisions,
+// queues them for the operator to approve/reject in bulk.
+const DEFAULT_CONFIG = {
+    maxPending: 50,
+    expiryMs: 30 * 60_000,
+};
+let nextId = 1;
+/**
+ * Manage an operator approval queue for daemon decisions.
+ */
+export class ApprovalQueue {
+    items = [];
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /** Queue a decision for approval. Returns the approval ID. */
+    enqueue(sessionTitle, actionType, detail, confidence = "medium", now = Date.now()) {
+        this.expire(now);
+        const id = `approval-${nextId++}`;
+        this.items.push({ id, timestamp: now, sessionTitle, actionType, detail, confidence, status: "pending" });
+        // enforce max pending
+        const pending = this.items.filter((i) => i.status === "pending");
+        if (pending.length > this.config.maxPending) {
+            pending[0].status = "expired";
+        }
+        return id;
+    }
+    /** Approve a queued decision by ID. */
+    approve(id) {
+        const item = this.items.find((i) => i.id === id && i.status === "pending");
+        if (!item)
+            return false;
+        item.status = "approved";
+        return true;
+    }
+    /** Reject a queued decision by ID. */
+    reject(id) {
+        const item = this.items.find((i) => i.id === id && i.status === "pending");
+        if (!item)
+            return false;
+        item.status = "rejected";
+        return true;
+    }
+    /** Approve all pending items. Returns count approved. */
+    approveAll() {
+        let count = 0;
+        for (const item of this.items) {
+            if (item.status === "pending") {
+                item.status = "approved";
+                count++;
+            }
+        }
+        return count;
+    }
+    /** Reject all pending items. Returns count rejected. */
+    rejectAll() {
+        let count = 0;
+        for (const item of this.items) {
+            if (item.status === "pending") {
+                item.status = "rejected";
+                count++;
+            }
+        }
+        return count;
+    }
+    /** Get all pending items. */
+    getPending(now = Date.now()) {
+        this.expire(now);
+        return this.items.filter((i) => i.status === "pending");
+    }
+    /** Get approved items that haven't been consumed yet. */
+    consumeApproved() {
+        const approved = this.items.filter((i) => i.status === "approved");
+        // remove consumed items
+        this.items = this.items.filter((i) => i.status !== "approved");
+        return approved;
+    }
+    /** Get queue statistics. */
+    getStats() {
+        const counts = { pending: 0, approved: 0, rejected: 0, expired: 0, total: this.items.length };
+        for (const i of this.items) {
+            if (i.status in counts)
+                counts[i.status]++;
+        }
+        return counts;
+    }
+    /** Format queue for TUI display. */
+    formatQueue(now = Date.now()) {
+        const pending = this.getPending(now);
+        if (pending.length === 0)
+            return ["  (no pending approvals)"];
+        const lines = [];
+        lines.push(`  Approval queue: ${pending.length} pending:`);
+        for (const p of pending) {
+            const age = Math.round((now - p.timestamp) / 60_000);
+            const conf = p.confidence === "high" ? "●" : p.confidence === "medium" ? "◐" : "○";
+            lines.push(`  ${conf} [${p.id}] ${p.sessionTitle}: ${p.actionType} — ${p.detail} (${age}m ago)`);
+        }
+        lines.push(`  Use /approve <id|all> or /reject <id|all>`);
+        return lines;
+    }
+    expire(now) {
+        const cutoff = now - this.config.expiryMs;
+        for (const item of this.items) {
+            if (item.status === "pending" && item.timestamp < cutoff) {
+                item.status = "expired";
+            }
+        }
+    }
+}
+//# sourceMappingURL=approval-queue.js.map

package/dist/approval-workflow.d.ts

@@ -0,0 +1,25 @@
+import type { ReasonerResult, Action } from "./types.js";
+import type { ApprovalQueue } from "./approval-queue.js";
+export interface ApprovalPolicy {
+    requireApprovalBelow: "high" | "medium" | "low";
+    alwaysApproveActions: string[];
+    alwaysRequireActions: string[];
+}
+/**
+ * Filter a reasoner result through the approval workflow.
+ * Actions that need approval are queued; approved actions pass through.
+ * Returns the filtered result with only immediately-executable actions.
+ */
+export declare function filterThroughApproval(result: ReasonerResult, queue: ApprovalQueue, policy?: Partial<ApprovalPolicy>): {
+    immediate: Action[];
+    queued: string[];
+};
+/**
+ * Determine if an action should be auto-approved.
+ */
+export declare function shouldAutoApprove(action: Action, confidence: ReasonerResult["confidence"], policy?: ApprovalPolicy): boolean;
+/**
+ * Format approval workflow status for TUI display.
+ */
+export declare function formatApprovalWorkflowStatus(queuedCount: number, immediateCount: number): string;
+//# sourceMappingURL=approval-workflow.d.ts.map

package/dist/approval-workflow.js

@@ -0,0 +1,78 @@
+// approval-workflow.ts — route low-confidence decisions through the approval
+// queue automatically. integrates reasoner confidence levels with the
+// existing ApprovalQueue to gate risky actions.
+const DEFAULT_POLICY = {
+    requireApprovalBelow: "low",
+    alwaysApproveActions: ["wait", "report_progress"],
+    alwaysRequireActions: ["remove_agent", "stop_session"],
+};
+/**
+ * Filter a reasoner result through the approval workflow.
+ * Actions that need approval are queued; approved actions pass through.
+ * Returns the filtered result with only immediately-executable actions.
+ */
+export function filterThroughApproval(result, queue, policy = {}) {
+    const p = { ...DEFAULT_POLICY, ...policy };
+    const immediate = [];
+    const queued = [];
+    for (const action of result.actions) {
+        if (shouldAutoApprove(action, result.confidence, p)) {
+            immediate.push(action);
+        }
+        else {
+            const session = actionSessionTitle(action);
+            const id = queue.enqueue(session ?? "fleet", action.action, actionSummary(action), result.confidence ?? "medium");
+            queued.push(id);
+        }
+    }
+    return { immediate, queued };
+}
+/**
+ * Determine if an action should be auto-approved.
+ */
+export function shouldAutoApprove(action, confidence, policy = DEFAULT_POLICY) {
+    // always-approve list
+    if (policy.alwaysApproveActions.includes(action.action))
+        return true;
+    // always-require list
+    if (policy.alwaysRequireActions.includes(action.action))
+        return false;
+    // confidence-based: require approval when confidence is BELOW threshold
+    // "low" threshold = require approval for nothing (all pass)
+    // "medium" threshold = require approval for "low" confidence
+    // "high" threshold = require approval for "low" and "medium"
+    const confidenceOrder = { high: 3, medium: 2, low: 1, undefined: 2 };
+    const thresholdOrder = { high: 3, medium: 2, low: 1 };
+    const confLevel = confidenceOrder[confidence ?? "undefined"];
+    const threshold = thresholdOrder[policy.requireApprovalBelow];
+    // auto-approve if confidence is AT or ABOVE the threshold
+    return confLevel > threshold;
+}
+function actionSessionTitle(action) {
+    if ("session" in action && typeof action.session === "string") {
+        return action.session;
+    }
+    return undefined;
+}
+function actionSummary(action) {
+    switch (action.action) {
+        case "send_input": return `send: "${action.text.slice(0, 60)}"`;
+        case "start_session": return "start session";
+        case "stop_session": return "stop session";
+        case "create_agent": return `create: ${action.title}`;
+        case "remove_agent": return "remove agent";
+        case "report_progress": return `progress: ${action.summary.slice(0, 60)}`;
+        case "complete_task": return `complete: ${action.summary.slice(0, 60)}`;
+        case "wait": return action.reason ?? "wait";
+        default: return action.action;
+    }
+}
+/**
+ * Format approval workflow status for TUI display.
+ */
+export function formatApprovalWorkflowStatus(queuedCount, immediateCount) {
+    if (queuedCount === 0)
+        return `all ${immediateCount} actions auto-approved`;
+    return `${immediateCount} auto-approved, ${queuedCount} queued for approval`;
+}
+//# sourceMappingURL=approval-workflow.js.map