clawatch 1.0.13 → 1.0.20

package/backend/dist/routes.js

@@ -1,21 +1,95 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const db_1 = __importDefault(require("./db"));
 const sessions_1 = require("./sessions");
 const projects_1 = require("./projects");
 const router = (0, express_1.Router)();
+// ---------- Profiles ----------
+router.get("/profiles", (_req, res) => {
+    const profiles = (0, sessions_1.discoverProfiles)();
+    res.json({ profiles });
+});
+// ---------- Version ----------
+router.get("/version", (_req, res) => {
+    const candidates = [
+        path.join(__dirname, "..", "..", "cli", "package.json"), // dev/source
+        path.join(__dirname, "..", "package.json"), // bundled in CLI
+    ];
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate)) {
+                const pkg = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+                if (pkg.version) {
+                    res.json({ version: pkg.version });
+                    return;
+                }
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    res.json({ version: "unknown" });
+});
 // ---------- Agents ----------
-router.get("/agents", (_req, res) => {
+router.get("/agents", async (_req, res) => {
     const statusFilter = _req.query.status || "active";
+    const profileFilter = _req.query.profile;
     const agents = db_1.default.prepare("SELECT * FROM agents ORDER BY costUsd DESC").all();
     // Filter by status
-    const filtered = statusFilter === "all"
+    let filtered = statusFilter === "all"
         ? agents
         : agents.filter((a) => a.status === statusFilter);
+    // Filter by profile: only return agents that have sessions in the selected profile
+    if (profileFilter) {
+        try {
+            const sessions = await (0, sessions_1.listSessions)(profileFilter);
+            const agentIdsInProfile = new Set(sessions.map((s) => s.agentId));
+            filtered = filtered.filter((a) => agentIdsInProfile.has(a.id));
+        }
+        catch {
+            // If profile lookup fails, return unfiltered
+        }
+    }
     res.json({ agents: filtered });
 });
 router.get("/agents/:id", (req, res) => {
@@ -97,53 +171,139 @@ router.post("/events", (req, res) => {
     res.status(201).json({ ok: true });
 });
 // ---------- Costs ----------
-router.get("/costs", (req, res) => {
-    const { agentId, from, to } = req.query;
-    let agentFilter = "";
-    const params = [];
-    if (agentId) {
-        agentFilter = " WHERE agentId = ?";
-        params.push(agentId);
-    }
-    // By agent
-    const byAgent = db_1.default.prepare(`
-    SELECT a.id as agentId, a.name, a.costUsd, a.tokenCount
-    FROM agents a ${agentId ? "WHERE a.id = ?" : ""}
-    ORDER BY a.costUsd DESC
-  `).all(...(agentId ? [agentId] : []));
-    // By model — query events with cost data
-    let modelQuery = `
-    SELECT json_extract(data, '$.model') as model,
-           SUM(json_extract(data, '$.costUsd')) as costUsd,
-           SUM(json_extract(data, '$.tokenCount')) as tokenCount
-    FROM events
-    WHERE type = 'cost'
-  `;
-    const modelParams = [];
-    if (agentId) {
-        modelQuery += " AND agentId = ?";
-        modelParams.push(agentId);
-    }
-    if (from) {
-        modelQuery += " AND timestamp >= ?";
-        modelParams.push(from);
-    }
-    if (to) {
-        modelQuery += " AND timestamp <= ?";
-        modelParams.push(to);
-    }
-    modelQuery += " GROUP BY model";
-    const byModel = db_1.default.prepare(modelQuery).all(...modelParams);
-    const totalUsd = byAgent.reduce((sum, a) => sum + (a.costUsd || 0), 0);
-    res.json({ totalUsd, byAgent, byModel });
+router.get("/costs", async (req, res) => {
+    try {
+        const { agentId, from, to, profile } = req.query;
+        // Get sessions (cached, authoritative source from JSONL files)
+        let sessions = await (0, sessions_1.listSessions)(profile);
+        // Apply filters
+        if (agentId) {
+            sessions = sessions.filter((s) => s.agentId === agentId);
+        }
+        if (from) {
+            sessions = sessions.filter((s) => s.lastActivityAt >= from);
+        }
+        if (to) {
+            sessions = sessions.filter((s) => s.startedAt <= to);
+        }
+        // Aggregate by agent
+        const agentMap = new Map();
+        // Aggregate by model
+        const modelMap = new Map();
+        for (const session of sessions) {
+            // By agent
+            const existing = agentMap.get(session.agentId);
+            if (existing) {
+                existing.costUsd += session.costUsd;
+                existing.tokenCount += session.tokenCount;
+            }
+            else {
+                agentMap.set(session.agentId, {
+                    agentId: session.agentId,
+                    name: session.agentId,
+                    costUsd: session.costUsd,
+                    tokenCount: session.tokenCount,
+                });
+            }
+            // By model — use costByModel from session summary
+            for (const mc of session.costByModel) {
+                const em = modelMap.get(mc.model);
+                if (em) {
+                    em.costUsd += mc.costUsd;
+                    em.tokenCount += mc.tokenCount;
+                }
+                else {
+                    modelMap.set(mc.model, { model: mc.model, costUsd: mc.costUsd, tokenCount: mc.tokenCount });
+                }
+            }
+        }
+        const byAgent = Array.from(agentMap.values()).sort((a, b) => b.costUsd - a.costUsd);
+        const byModel = Array.from(modelMap.values()).sort((a, b) => b.costUsd - a.costUsd);
+        const totalUsd = byAgent.reduce((sum, a) => sum + a.costUsd, 0);
+        res.json({ totalUsd, byAgent, byModel });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || "Failed to get costs" });
+    }
 });
 // ---------- Alerts ----------
-router.get("/alerts", (_req, res) => {
-    const alerts = db_1.default.prepare("SELECT * FROM alerts ORDER BY timestamp DESC LIMIT 100").all().map((a) => ({
+router.get("/alerts", async (req, res) => {
+    const limit = Math.min(Math.max(parseInt(req.query.limit, 10) || 5, 1), 100);
+    const offset = Math.max(parseInt(req.query.offset, 10) || 0, 0);
+    const severityParam = req.query.severity;
+    const acknowledgedParam = req.query.acknowledged;
+    const agentIdParam = req.query.agentId;
+    const profileParam = req.query.profile;
+    const conditions = [];
+    const params = [];
+    // Profile filter: restrict to agents that belong to this profile
+    if (profileParam) {
+        const sessions = await (0, sessions_1.listSessions)(profileParam);
+        const agentIds = [...new Set(sessions.map((s) => s.agentId))];
+        if (agentIds.length > 0) {
+            conditions.push(`agentId IN (${agentIds.map(() => "?").join(", ")})`);
+            params.push(...agentIds);
+        }
+        else {
+            // No agents in this profile — return empty
+            res.json({ alerts: [], total: 0 });
+            return;
+        }
+    }
+    if (severityParam) {
+        const severities = severityParam.split(",").map((s) => s.trim());
+        conditions.push(`severity IN (${severities.map(() => "?").join(", ")})`);
+        params.push(...severities);
+    }
+    if (acknowledgedParam === "true") {
+        conditions.push("acknowledged = 1");
+    }
+    else if (acknowledgedParam === "false") {
+        conditions.push("acknowledged = 0");
+    }
+    if (agentIdParam) {
+        conditions.push("agentId = ?");
+        params.push(agentIdParam);
+    }
+    const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+    const total = db_1.default.prepare(`SELECT COUNT(*) as cnt FROM alerts${where}`).get(...params).cnt;
+    const alerts = db_1.default.prepare(`SELECT * FROM alerts${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`).all(...params, limit, offset).map((a) => ({
         ...a,
         acknowledged: Boolean(a.acknowledged),
     }));
-    res.json({ alerts });
+    res.json({ alerts, total });
+});
+router.post("/alerts/acknowledge-all", async (req, res) => {
+    const severityParam = req.query.severity;
+    const agentIdParam = req.query.agentId;
+    const profileParam = req.query.profile;
+    const conditions = ["acknowledged = 0"];
+    const params = [];
+    // Profile filter
+    if (profileParam) {
+        const sessions = await (0, sessions_1.listSessions)(profileParam);
+        const agentIds = [...new Set(sessions.map((s) => s.agentId))];
+        if (agentIds.length > 0) {
+            conditions.push(`agentId IN (${agentIds.map(() => "?").join(", ")})`);
+            params.push(...agentIds);
+        }
+        else {
+            res.json({ ok: true, count: 0 });
+            return;
+        }
+    }
+    if (severityParam) {
+        const severities = severityParam.split(",").map((s) => s.trim());
+        conditions.push(`severity IN (${severities.map(() => "?").join(", ")})`);
+        params.push(...severities);
+    }
+    if (agentIdParam) {
+        conditions.push("agentId = ?");
+        params.push(agentIdParam);
+    }
+    const where = ` WHERE ${conditions.join(" AND ")}`;
+    const result = db_1.default.prepare(`UPDATE alerts SET acknowledged = 1${where}`).run(...params);
+    res.json({ ok: true, count: result.changes });
 });
 router.post("/alerts/:id/acknowledge", (req, res) => {
     const result = db_1.default.prepare("UPDATE alerts SET acknowledged = 1 WHERE id = ?").run(req.params.id);
@@ -153,12 +313,309 @@ router.post("/alerts/:id/acknowledge", (req, res) => {
     }
     res.json({ ok: true });
 });
+// --- Alert summary generation helpers ---
+function isMeaningfulError(error) {
+    const cleaned = stripLogPrefix(error).trim();
+    // Filter out JSON fragments, single chars, pure punctuation, etc.
+    if (cleaned.length < 5)
+        return false;
+    if (/^[{}\[\],;:."'\s]+$/.test(cleaned))
+        return false;
+    if (/^\w+:\s*\d+[,}]?$/.test(cleaned))
+        return false; // "key: 123"
+    return true;
+}
+function generateErrorSummary(relatedErrors, agentName) {
+    if (relatedErrors.length === 0) {
+        return { summary: "Errors detected", description: `${agentName} encountered errors recently.` };
+    }
+    // Group errors by message, filtering out meaningless fragments
+    const groups = new Map();
+    for (const e of relatedErrors) {
+        const key = e.error;
+        const existing = groups.get(key);
+        if (existing) {
+            existing.count++;
+            if (e.timestamp > existing.latest)
+                existing.latest = e.timestamp;
+        }
+        else {
+            groups.set(key, { count: 1, latest: e.timestamp });
+        }
+    }
+    // Find the most frequent *meaningful* error
+    let topError = "";
+    let topCount = 0;
+    for (const [msg, info] of groups) {
+        if (info.count > topCount && isMeaningfulError(msg)) {
+            topError = msg;
+            topCount = info.count;
+        }
+    }
+    // If no meaningful error found, fall back to any error
+    if (!topError) {
+        for (const [msg, info] of groups) {
+            if (info.count > topCount) {
+                topError = msg;
+                topCount = info.count;
+            }
+        }
+    }
+    // Pattern-match the top error for a human-readable summary
+    const summary = humanizeError(topError, agentName);
+    // Generate a plain-English description — no raw error text, no counts (frontend shows ×N)
+    const description = generatePlainDescription(summary, agentName, topError);
+    return { summary, description };
+}
+function generatePlainDescription(title, agentName, _topError) {
+    // Map known titles/patterns to plain-English impact descriptions
+    if (/can't connect|connection refused/i.test(title))
+        return `${agentName} is unable to reach a service it depends on. This may prevent it from completing its tasks until the service is back online.`;
+    if (/can't reach|DNS failure/i.test(title))
+        return `${agentName} can't look up a server address. The remote service may be down or there could be a network issue.`;
+    if (/connection lost|connection reset/i.test(title))
+        return `${agentName} keeps losing its connection to an external service. This usually means the remote server is unstable or overloaded.`;
+    if (/timed out/i.test(title))
+        return `${agentName} waited too long for a response. The target service may be slow or unresponsive.`;
+    if (/rate limit/i.test(title))
+        return `${agentName} is making too many API calls and being throttled. It needs to slow down or wait before retrying.`;
+    if (/authentication failed|auth token expired/i.test(title))
+        return `${agentName} can't authenticate with an external service. Its credentials may need to be refreshed or reconfigured.`;
+    if (/access denied|permission/i.test(title))
+        return `${agentName} tried to do something it doesn't have permission for. Check its access rights.`;
+    if (/Slack credentials not configured/i.test(title))
+        return `${agentName} can't send messages to Slack because the bot token isn't set up. Configure the Slack integration to fix this.`;
+    if (/message delivery failing/i.test(title))
+        return `${agentName} is failing to deliver messages. This may be caused by missing credentials or a service outage.`;
+    if (/Slack connection/i.test(title))
+        return `${agentName} is having trouble staying connected to Slack. The connection keeps dropping or timing out.`;
+    if (/crashed|unhandled/i.test(title))
+        return `${agentName} crashed unexpectedly. It may need to be restarted or the underlying bug needs to be fixed.`;
+    if (/misconfigured tool|configuration error/i.test(title))
+        return `${agentName} has a configuration issue that may cause some features to not work correctly. Review its settings.`;
+    if (/skill path/i.test(title))
+        return `${agentName} has a skill that points to an invalid location. The skill may not load correctly.`;
+    if (/can't find a required file|missing file/i.test(title))
+        return `${agentName} is looking for a file that doesn't exist. A dependency may be missing or a path may be wrong.`;
+    if (/invalid file operation/i.test(title))
+        return `${agentName} tried to read a directory as a file. There may be a path configuration issue.`;
+    if (/missing required command/i.test(title))
+        return `${agentName} needs a system command that isn't installed. Install the missing dependency.`;
+    if (/process was killed/i.test(title))
+        return `${agentName} was forcefully stopped. This could be due to resource limits or a manual intervention.`;
+    if (/code bug|null reference|type error/i.test(title))
+        return `${agentName} hit a bug in its code. This is likely a software issue that needs a fix.`;
+    if (/malformed data|invalid data/i.test(title))
+        return `${agentName} received data it couldn't understand. The data source may have changed format.`;
+    if (/database/i.test(title))
+        return `${agentName} is having trouble accessing its database. It may be locked by another process or corrupted.`;
+    if (/hostname conflict/i.test(title))
+        return `${agentName} detected a network naming conflict. Multiple services may be competing for the same name.`;
+    if (/spending exceeded/i.test(title))
+        return `${agentName} has gone over its budget. Consider reviewing its usage or adjusting the threshold.`;
+    // Generic fallback — still meaningful
+    return `${agentName} ran into a problem that may affect its ability to work properly. Check the technical details for more information.`;
+}
+// Strip common log prefixes: timestamps, log levels, bracketed tags
+function stripLogPrefix(error) {
+    let cleaned = error;
+    // Strip ISO/custom timestamps at start: "2026-03-10T11:40:54.880+02:00 " or "[2026-03-10 ...]"
+    cleaned = cleaned.replace(/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[\d.+:ZT-]*\s*/g, "");
+    // Strip bracketed tags: [tools], [ERROR], [warn], etc.
+    cleaned = cleaned.replace(/^\[[\w.-]+\]\s*/g, "");
+    // Strip again (sometimes multiple tags)
+    cleaned = cleaned.replace(/^\[[\w.-]+\]\s*/g, "");
+    // Strip log levels
+    cleaned = cleaned.replace(/^(ERROR|WARN|INFO|DEBUG|FATAL|TRACE)[:\s]+/i, "");
+    return cleaned.trim();
+}
+function humanizeError(error, agentName) {
+    // Preprocess: strip log timestamps/tags to get the actual error content
+    const cleanedError = stripLogPrefix(error);
+    const patterns = [
+        // Network errors
+        [/ECONNREFUSED/i, `${agentName} can't connect to a service`],
+        [/ECONNRESET/i, `${agentName} lost connection unexpectedly`],
+        [/ETIMEDOUT/i, `${agentName} connection timed out`],
+        [/ENOTFOUND/i, `${agentName} can't reach a remote server`],
+        [/EADDRINUSE/i, `${agentName} port already in use`],
+        [/EPERM|EACCES/i, `${agentName} permission denied`],
+        [/ENOMEM|out of memory/i, `${agentName} ran out of memory`],
+        // HTTP errors
+        [/rate.?limit/i, `${agentName} hit API rate limit`],
+        [/401|unauthorized/i, `${agentName} authentication failed`],
+        [/403|forbidden/i, `${agentName} access denied`],
+        [/500|internal server error/i, `Remote server error for ${agentName}`],
+        [/502|bad gateway/i, `Bad gateway error for ${agentName}`],
+        [/503|service unavailable/i, `Service unavailable for ${agentName}`],
+        [/504|gateway timeout/i, `Gateway timeout for ${agentName}`],
+        // Code errors
+        [/Cannot read propert/i, `${agentName} hit a code bug (null reference)`],
+        [/is not a function/i, `${agentName} hit a code bug (type error)`],
+        [/JSON\.parse|Unexpected token/i, `${agentName} received malformed data`],
+        [/SQLITE_BUSY/i, `${agentName} database is locked`],
+        [/SQLITE_CORRUPT/i, `${agentName} database corruption detected`],
+        // Auth/cert
+        [/token.*expir/i, `${agentName} auth token expired`],
+        [/CERT_|certificate/i, `${agentName} SSL certificate error`],
+        // File/path errors
+        [/ENOENT|no such file/i, `${agentName} can't find a required file`],
+        [/EISDIR/i, `${agentName} invalid file operation`],
+        [/spawn.*ENOENT|command not found/i, `${agentName} missing required command`],
+        [/killed|SIGKILL|SIGTERM/i, `${agentName} process was killed`],
+        // OpenClaw / gateway specific
+        [/[Ss]lack\s*bot\s*token\s*missing/i, `${agentName} Slack credentials not configured`],
+        [/[Rr]etry failed for delivery/i, `${agentName} message delivery failing`],
+        [/delivery.*failed|failed.*delivery/i, `${agentName} message delivery failing`],
+        [/socket.?mode failed/i, `${agentName} Slack connection failing`],
+        [/pong wasn't received|pong.*timeout/i, `${agentName} Slack connection timing out`],
+        [/[Uu]nhandled promise rejection/i, `${agentName} crashed (unhandled error)`],
+        [/allowlist contains unknown/i, `${agentName} has misconfigured tool settings`],
+        [/[Ss]kipping skill path/i, `${agentName} has a skill path issue`],
+        [/hostname conflict/i, `${agentName} network hostname conflict`],
+        // Generic patterns (broad — keep last)
+        [/timeout/i, `${agentName} operation timed out`],
+        [/connection refused/i, `${agentName} can't connect to a service`],
+        [/connection reset/i, `${agentName} lost connection`],
+        [/missing.*config|config.*missing/i, `${agentName} missing configuration`],
+        [/crash|fatal|panic/i, `${agentName} crashed`],
+    ];
+    for (const [pattern, summary] of patterns) {
+        if (pattern.test(cleanedError))
+            return summary;
+    }
+    // Smart fallback: interpret the error instead of truncating
+    // Try "ErrorType: message" format
+    const typeMatch = cleanedError.match(/^(\w+Error):\s*(.+?)(?:\n|$)/);
+    if (typeMatch) {
+        const shortMsg = typeMatch[2].trim();
+        return shortMsg.length > 50 ? `${agentName}: ${shortMsg.slice(0, 47)}...` : `${agentName}: ${shortMsg}`;
+    }
+    // Look for a verb phrase
+    const actionMatch = cleanedError.match(/(failed to \w+|cannot \w+|unable to \w+|could not \w+)/i);
+    if (actionMatch) {
+        return `${agentName} ${actionMatch[1].toLowerCase()}`;
+    }
+    // Keyword-based categorization — produce a real summary, not a truncation
+    const lower = cleanedError.toLowerCase();
+    if (lower.includes("connect") || lower.includes("socket"))
+        return `${agentName} connection issue`;
+    if (lower.includes("timeout") || lower.includes("timed out"))
+        return `${agentName} operation timed out`;
+    if (lower.includes("permission") || lower.includes("denied") || lower.includes("access"))
+        return `${agentName} permission error`;
+    if (lower.includes("invalid") || lower.includes("unexpected") || lower.includes("unknown"))
+        return `${agentName} configuration error`;
+    if (lower.includes("missing") || lower.includes("not found"))
+        return `${agentName} missing resource`;
+    if (lower.includes("failed") || lower.includes("error") || lower.includes("crash"))
+        return `${agentName} operation failed`;
+    // Last resort: first clause only, very short
+    const clean = cleanedError.replace(/\n.*/s, "").trim();
+    if (!clean || clean.length < 5) {
+        return `${agentName} encountered errors`;
+    }
+    const clause = clean.split(/[,;(]/)[0].trim();
+    return clause.length > 40 ? `${agentName} error` : `${agentName}: ${clause}`;
+}
+function cleanErrorForDisplay(error) {
+    // Strip log prefixes and stack trace, keep just the meaningful error
+    const cleaned = stripLogPrefix(error.split("\n")[0].trim());
+    return cleaned.length > 120 ? cleaned.slice(0, 117) + "..." : cleaned;
+}
+function generateStuckSummary(agentName, durationMinutes) {
+    return {
+        summary: `${agentName} stopped responding`,
+        description: `${agentName} hasn't sent a heartbeat in ${durationMinutes} minutes. The agent may have crashed, frozen, or lost its connection. It needs to be restarted or investigated.`,
+    };
+}
+function generateCostSummary(agentName, currentCost, threshold) {
+    const overage = currentCost - threshold;
+    return {
+        summary: `${agentName} spending exceeded $${threshold}`,
+        description: `${agentName} has spent $${currentCost.toFixed(2)}, which is $${overage.toFixed(2)} over the $${threshold.toFixed(2)} threshold. This could mean the agent is running longer than expected or processing more data than usual.`,
+    };
+}
+router.get("/alerts/:id/details", (req, res) => {
+    const alert = db_1.default.prepare("SELECT * FROM alerts WHERE id = ?").get(req.params.id);
+    if (!alert) {
+        res.status(404).json({ error: "Alert not found" });
+        return;
+    }
+    alert.acknowledged = Boolean(alert.acknowledged);
+    // Get agent info
+    const agent = db_1.default.prepare("SELECT id, name, status, lastHeartbeat, costUsd FROM agents WHERE id = ?")
+        .get(alert.agentId);
+    const agentName = agent?.name || alert.agentId;
+    let relatedErrors = [];
+    let context = {};
+    let summary = "";
+    let description = "";
+    if (alert.type === "error") {
+        // Error spike: get the actual error events within the spike window before the alert
+        const ERROR_SPIKE_WINDOW_MS = parseInt(process.env.ERROR_SPIKE_WINDOW_MS || "60000", 10);
+        const windowStart = new Date(new Date(alert.timestamp).getTime() - ERROR_SPIKE_WINDOW_MS).toISOString();
+        relatedErrors = db_1.default.prepare(`
+      SELECT type, timestamp, data FROM events
+      WHERE agentId = ? AND type = 'error' AND timestamp > ? AND timestamp <= ?
+      ORDER BY timestamp DESC
+    `).all(alert.agentId, windowStart, alert.timestamp).map((e) => {
+            const parsed = JSON.parse(e.data);
+            return {
+                timestamp: e.timestamp,
+                error: parsed.error || parsed.message || "Unknown error",
+                raw: parsed,
+            };
+        });
+        const gen = generateErrorSummary(relatedErrors, agentName);
+        summary = gen.summary;
+        description = gen.description;
+    }
+    else if (alert.type === "stuck") {
+        // Stuck agent: show how long it's been stuck and last heartbeat
+        if (agent) {
+            const stuckSince = new Date(agent.lastHeartbeat);
+            const stuckDurationMs = new Date(alert.timestamp).getTime() - stuckSince.getTime();
+            const stuckMinutes = Math.round(stuckDurationMs / 60000);
+            context = {
+                lastHeartbeat: agent.lastHeartbeat,
+                stuckDurationMs,
+                stuckDurationMinutes: stuckMinutes,
+                agentStatus: agent.status,
+            };
+            const gen = generateStuckSummary(agentName, stuckMinutes);
+            summary = gen.summary;
+            description = gen.description;
+        }
+    }
+    else if (alert.type === "cost_spike") {
+        // Cost threshold: show current spend and threshold
+        const COST_THRESHOLD_USD = parseFloat(process.env.COST_THRESHOLD_USD || "10");
+        context = {
+            currentCostUsd: agent?.costUsd || 0,
+            thresholdUsd: COST_THRESHOLD_USD,
+            overage: (agent?.costUsd || 0) - COST_THRESHOLD_USD,
+        };
+        const gen = generateCostSummary(agentName, agent?.costUsd || 0, COST_THRESHOLD_USD);
+        summary = gen.summary;
+        description = gen.description;
+    }
+    res.json({
+        alert,
+        agent: agent ? { id: agent.id, name: agent.name, status: agent.status } : null,
+        relatedErrors,
+        context,
+        title: summary,
+        description,
+    });
+});
 // ---------- Sessions (from JSONL files) ----------
 router.get("/sessions", async (req, res) => {
     try {
-        let sessions = await (0, sessions_1.listSessions)();
+        const profileFilter = req.query.profile;
+        let sessions = await (0, sessions_1.listSessions)(profileFilter);
         // Filter by agentId
-        const { agentId, status, sort, limit } = req.query;
+        const { agentId, status, sort, limit, offset } = req.query;
         if (agentId) {
             sessions = sessions.filter((s) => s.agentId === agentId);
         }
@@ -176,11 +633,20 @@ router.get("/sessions", async (req, res) => {
             sessions.sort((a, b) => b.tokenCount - a.tokenCount);
         }
         // default: already sorted by lastActivityAt DESC
-        // Limit
-        const limitStr = Array.isArray(limit) ? limit[0] : limit;
-        const max = Math.min(parseInt(limitStr, 10) || 50, 500);
-        sessions = sessions.slice(0, max);
-        res.json({ sessions });
+        // Total count (after filtering, before pagination)
+        const total = sessions.length;
+        // Pagination
+        const limitVal = Math.min(Math.max(parseInt(limit, 10) || 20, 1), 500);
+        const offsetVal = Math.max(parseInt(offset, 10) || 0, 0);
+        sessions = sessions.slice(offsetVal, offsetVal + limitVal);
+        // Attach project tags to each session
+        const sessionIds = sessions.map((s) => s.id);
+        const projectTags = (0, projects_1.bulkGetSessionProjects)(sessionIds);
+        const sessionsWithProjects = sessions.map((s) => ({
+            ...s,
+            projects: projectTags.get(s.id) || [],
+        }));
+        res.json({ sessions: sessionsWithProjects, total });
     }
     catch (err) {
         res.status(500).json({ error: err.message || "Failed to list sessions" });
@@ -188,7 +654,8 @@ router.get("/sessions", async (req, res) => {
 });
 router.get("/sessions/:id", async (req, res) => {
     try {
-        const detail = await (0, sessions_1.getSessionDetail)(req.params.id);
+        const profileFilter = req.query.profile;
+        const detail = await (0, sessions_1.getSessionDetail)(req.params.id, profileFilter);
         if (!detail) {
             res.status(404).json({ error: "Session not found" });
             return;
@@ -209,6 +676,162 @@ router.get("/sessions/:id/suggestions", async (req, res) => {
         res.status(500).json({ error: err.message || "Failed to get suggestions" });
     }
 });
+// ---------- Session Project Tags ----------
+router.put("/sessions/:id/projects", (req, res) => {
+    const { projectIds } = req.body;
+    if (!Array.isArray(projectIds)) {
+        res.status(400).json({ error: "projectIds must be an array" });
+        return;
+    }
+    (0, projects_1.setSessionProjects)(req.params.id, projectIds);
+    res.json({ ok: true });
+});
+router.delete("/sessions/:id/projects/:projectId", (req, res) => {
+    const ok = (0, projects_1.removeSessionFromProject)(req.params.projectId, req.params.id);
+    if (!ok) {
+        res.status(404).json({ error: "Project tag not found on session" });
+        return;
+    }
+    res.json({ ok: true });
+});
+router.get("/sessions/:id/projects", (req, res) => {
+    const projects = (0, projects_1.getSessionProjects)(req.params.id);
+    res.json({ projects });
+});
+// ---------- Analytics ----------
+router.get("/analytics", async (req, res) => {
+    try {
+        const profile = req.query.profile;
+        const groupBy = req.query.groupBy || "day";
+        const from = req.query.from;
+        const to = req.query.to;
+        let sessions = await (0, sessions_1.listSessions)(profile);
+        // For hourly view, default to last 3 days if no from specified
+        let effectiveFrom = from;
+        if (groupBy === "hour" && !from) {
+            const threeDaysAgo = new Date();
+            threeDaysAgo.setUTCDate(threeDaysAgo.getUTCDate() - 3);
+            effectiveFrom = threeDaysAgo.toISOString();
+        }
+        // Filter by date range using startedAt
+        if (effectiveFrom)
+            sessions = sessions.filter((s) => s.startedAt >= effectiveFrom);
+        if (to)
+            sessions = sessions.filter((s) => s.startedAt <= to);
+        // Get project tags for all sessions
+        const sessionIds = sessions.map((s) => s.id);
+        const projectTags = (0, projects_1.bulkGetSessionProjects)(sessionIds);
+        // Helper: get bucket date key for a session
+        function getBucketKey(dateStr) {
+            const d = new Date(dateStr);
+            if (groupBy === "hour") {
+                return d.toISOString().slice(0, 13) + ":00"; // "2026-03-10T14:00"
+            }
+            if (groupBy === "week") {
+                // ISO week starts on Monday
+                const day = d.getUTCDay();
+                const diff = (day === 0 ? -6 : 1) - day; // adjust to Monday
+                const monday = new Date(d);
+                monday.setUTCDate(monday.getUTCDate() + diff);
+                return monday.toISOString().slice(0, 10);
+            }
+            return d.toISOString().slice(0, 10);
+        }
+        // Helper: generate all date keys between min and max
+        function generateAllKeys(minDate, maxDate) {
+            const keys = [];
+            const current = new Date(minDate);
+            const end = new Date(maxDate);
+            while (current <= end) {
+                if (groupBy === "hour") {
+                    keys.push(current.toISOString().slice(0, 13) + ":00");
+                    current.setUTCHours(current.getUTCHours() + 1);
+                }
+                else if (groupBy === "week") {
+                    keys.push(current.toISOString().slice(0, 10));
+                    current.setUTCDate(current.getUTCDate() + 7);
+                }
+                else {
+                    keys.push(current.toISOString().slice(0, 10));
+                    current.setUTCDate(current.getUTCDate() + 1);
+                }
+            }
+            return keys;
+        }
+        const totalMap = new Map();
+        const agentMap = new Map();
+        const projectMap = new Map();
+        for (const s of sessions) {
+            const key = getBucketKey(s.startedAt);
+            // Total
+            const tb = totalMap.get(key) || { costUsd: 0, tokenCount: 0, sessionCount: 0 };
+            tb.costUsd += s.costUsd;
+            tb.tokenCount += s.tokenCount;
+            tb.sessionCount += 1;
+            totalMap.set(key, tb);
+            // By agent
+            if (!agentMap.has(s.agentId))
+                agentMap.set(s.agentId, new Map());
+            const ab = agentMap.get(s.agentId).get(key) || { costUsd: 0, tokenCount: 0, sessionCount: 0 };
+            ab.costUsd += s.costUsd;
+            ab.tokenCount += s.tokenCount;
+            ab.sessionCount += 1;
+            agentMap.get(s.agentId).set(key, ab);
+            // By project (session can belong to multiple projects)
+            const projects = projectTags.get(s.id) || [];
+            for (const p of projects) {
+                if (!projectMap.has(p.id))
+                    projectMap.set(p.id, { name: p.name, buckets: new Map() });
+                const pb = projectMap.get(p.id).buckets.get(key) || { costUsd: 0, tokenCount: 0, sessionCount: 0 };
+                pb.costUsd += s.costUsd;
+                pb.tokenCount += s.tokenCount;
+                pb.sessionCount += 1;
+                projectMap.get(p.id).buckets.set(key, pb);
+            }
+        }
+        // Determine date range for zero-filling
+        const allKeys = [...totalMap.keys()].sort();
+        let rangeStart = effectiveFrom ? getBucketKey(effectiveFrom) : (from ? getBucketKey(from) : allKeys[0]);
+        let rangeEnd = to ? getBucketKey(to) : allKeys[allKeys.length - 1];
+        // For hourly view, always extend to current time so chart isn't cut off
+        if (groupBy === "hour" && !to) {
+            const nowKey = getBucketKey(new Date().toISOString());
+            if (!rangeEnd || nowKey > rangeEnd)
+                rangeEnd = nowKey;
+        }
+        if (!rangeStart || !rangeEnd) {
+            res.json({ buckets: [], byAgent: [], byProject: [] });
+            return;
+        }
+        const allDates = generateAllKeys(rangeStart, rangeEnd);
+        const zeroBucket = { costUsd: 0, tokenCount: 0, sessionCount: 0 };
+        // Build response with zero-filled buckets
+        const buckets = allDates.map((date) => ({
+            date,
+            ...(totalMap.get(date) || zeroBucket),
+        }));
+        const byAgent = [...agentMap.entries()].map(([agentId, bMap]) => ({
+            agentId,
+            name: agentId,
+            buckets: allDates.map((date) => ({
+                date,
+                ...(bMap.get(date) || zeroBucket),
+            })),
+        }));
+        const byProject = [...projectMap.entries()].map(([projectId, { name, buckets: bMap }]) => ({
+            projectId,
+            name,
+            buckets: allDates.map((date) => ({
+                date,
+                ...(bMap.get(date) || zeroBucket),
+            })),
+        }));
+        res.json({ buckets, byAgent, byProject });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || "Failed to get analytics" });
+    }
+});
 // ---------- Projects ----------
 router.post("/projects", (req, res) => {
     const { name, description } = req.body;
@@ -219,8 +842,18 @@ router.post("/projects", (req, res) => {
     const project = (0, projects_1.createProject)(name, description);
     res.status(201).json(project);
 });
-router.get("/projects", (_req, res) => {
-    const projects = (0, projects_1.listProjects)();
+router.get("/projects", async (_req, res) => {
+    const profileParam = _req.query.profile;
+    let projects = (0, projects_1.listProjects)();
+    // Filter projects to only include those with sessions in the selected profile
+    if (profileParam) {
+        const sessions = await (0, sessions_1.listSessions)(profileParam);
+        const profileSessionIds = new Set(sessions.map((s) => s.id));
+        projects = projects.filter((p) => {
+            const projectSessionIds = db_1.default.prepare("SELECT sessionId FROM project_sessions WHERE projectId = ?").all(p.id);
+            return projectSessionIds.some((ps) => profileSessionIds.has(ps.sessionId));
+        });
+    }
     res.json({ projects });
 });
 router.get("/projects/:id", async (req, res) => {