agenttop 0.10.6 → 0.11.0

package/dist/{chunk-24HX2MSZ.js → chunk-LPXME2WB.js}

@@ -6,7 +6,9 @@ import { join } from "path";
 import { homedir } from "os";
 var getConfigDir = () => {
   const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg ? join(xdg, "agenttop") : join(homedir(), ".config", "agenttop");
+  if (xdg) return join(xdg, "agenttop");
+  if (process.platform === "win32" && process.env.APPDATA) return join(process.env.APPDATA, "agenttop");
+  return join(homedir(), ".config", "agenttop");
 };
 var getConfigPath = () => join(getConfigDir(), "config.json");
 var defaultConfig = () => ({
@@ -21,7 +23,10 @@ var defaultConfig = () => ({
   },
   alerts: {
     logFile: join(getConfigDir(), "alerts.jsonl"),
-    enabled: true
+    enabled: true,
+    staleTimeout: 60,
+    staleAlertSeverity: "warn",
+    custom: []
   },
   updates: {
     checkOnLaunch: true,
@@ -51,7 +56,11 @@ var defaultConfig = () => ({
     swapPanels: "S",
     closePanel: "X",
     sidebarNarrower: "<",
-    sidebarWider: ">"
+    sidebarWider: ">",
+    alertRules: "r",
+    pin: "p",
+    pinMoveUp: "P",
+    pinMoveDown: "ctrl+p"
   },
   security: {
     enabled: true,
@@ -67,13 +76,15 @@ var defaultConfig = () => ({
     hook: "pending",
     mcp: "pending",
     theme: "pending",
-    tour: "pending"
+    tour: "pending",
+    autoUpdate: "pending"
   },
   archived: {},
   archiveExpiryDays: 0,
   sidebarWidth: 30,
   theme: "one-dark",
-  customThemes: {}
+  customThemes: {},
+  pinnedSessions: []
 });
 var deepMerge = (target, source) => {
   const result = { ...target };
@@ -184,21 +195,46 @@ var deleteSessionFiles = (outputFiles) => {
     }
   }
 };
+var pinSession = (sessionId) => {
+  const config = loadConfig();
+  if (!config.pinnedSessions.includes(sessionId)) {
+    config.pinnedSessions.push(sessionId);
+    saveConfig(config);
+  }
+};
+var unpinSession = (sessionId) => {
+  const config = loadConfig();
+  config.pinnedSessions = config.pinnedSessions.filter((id) => id !== sessionId);
+  saveConfig(config);
+};
+var movePinned = (sessionId, direction) => {
+  const config = loadConfig();
+  const idx = config.pinnedSessions.indexOf(sessionId);
+  if (idx === -1) return;
+  const newIdx = direction === "up" ? idx - 1 : idx + 1;
+  if (newIdx < 0 || newIdx >= config.pinnedSessions.length) return;
+  config.pinnedSessions.splice(idx, 1);
+  config.pinnedSessions.splice(newIdx, 0, sessionId);
+  saveConfig(config);
+};
 
 // src/mcp/server.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4, dirname } from "path";
+import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // src/discovery/sessions.ts
-import { readdirSync as readdirSync2, statSync as statSync2, readlinkSync, openSync, readSync, closeSync } from "fs";
+import { readdirSync as readdirSync2, statSync as statSync2, openSync, readSync, closeSync } from "fs";
 import { join as join3, basename } from "path";
-import { execSync } from "child_process";
 
 // src/config.ts
 import { existsSync as existsSync2, realpathSync, readdirSync } from "fs";
-import { homedir as homedir2, platform } from "os";
+import { homedir as homedir2, platform, tmpdir, userInfo } from "os";
 import { join as join2 } from "path";
+var os = platform();
 var resolvePath = (p) => {
   try {
     return realpathSync(p);
@@ -206,13 +242,25 @@ var resolvePath = (p) => {
     return p;
   }
 };
-var getUid = () => process.getuid?.() ?? 0;
-var isRoot = () => getUid() === 0;
-var getTmpDir = () => resolvePath(platform() === "darwin" ? "/private/tmp" : "/tmp");
+var getUid = () => {
+  const uid = process.getuid?.();
+  if (uid !== void 0) return String(uid);
+  try {
+    return userInfo().username;
+  } catch {
+    return process.env["USERNAME"] || process.env["USER"] || "0";
+  }
+};
+var isRoot = () => process.getuid?.() === 0;
+var getTmpDir = () => {
+  if (os === "darwin") return resolvePath("/private/tmp");
+  if (os === "win32") return tmpdir();
+  return resolvePath("/tmp");
+};
 var getTaskDirs = (allUsers) => {
   const tmp = getTmpDir();
   const uid = getUid();
-  if (allUsers) {
+  if (allUsers && os !== "win32") {
     try {
       const dirs2 = readdirSync(tmp).filter((d) => d.startsWith("claude-")).filter((d) => !d.endsWith("-cwd")).map((d) => join2(tmp, d));
       if (dirs2.length > 0) return dirs2;
@@ -242,50 +290,213 @@ var getProjectsDirs = (allUsers) => {
     addDir(join2("/root", ".claude", "projects"));
     const sudoUser = process.env["SUDO_USER"];
     if (sudoUser) {
-      const homeBase = platform() === "darwin" ? "/Users" : "/home";
+      const homeBase = os === "darwin" ? "/Users" : "/home";
       addDir(join2(homeBase, sudoUser, ".claude", "projects"));
     }
   }
-  if (allUsers) {
+  if (allUsers && os !== "win32") {
     try {
-      const homeBase = platform() === "darwin" ? "/Users" : "/home";
+      const homeBase = os === "darwin" ? "/Users" : "/home";
       for (const user of readdirSync(homeBase)) {
         addDir(join2(homeBase, user, ".claude", "projects"));
       }
     } catch {
     }
-    addDir(join2("/root", ".claude", "projects"));
+    if (os !== "darwin") addDir(join2("/root", ".claude", "projects"));
+  }
+  if (allUsers && os === "win32") {
+    try {
+      for (const user of readdirSync("C:\\Users")) {
+        addDir(join2("C:\\Users", user, ".claude", "projects"));
+      }
+    } catch {
+    }
   }
   return dirs;
 };
 
-// src/discovery/sessions.ts
+// src/discovery/types.ts
+var STATUS_PRIORITY = {
+  waiting: 0,
+  stale: 1,
+  active: 2,
+  inactive: 3
+};
+var isToolResult = (event) => "toolUseId" in event;
+var isToolCall = (event) => "toolName" in event;
+
+// src/discovery/platform.ts
+import { execFileSync, execFile } from "child_process";
+import { readlinkSync } from "fs";
+import { readlink } from "fs/promises";
+import { platform as platform2 } from "os";
+var os2 = platform2();
+var parsePsLine = (line) => {
+  const parts = line.trim().split(/\s+/);
+  const pid = parseInt(parts[1], 10);
+  if (isNaN(pid)) return null;
+  const command = parts.slice(10).join(" ");
+  if (command.startsWith("sudo")) return null;
+  return {
+    pid,
+    cpu: parseFloat(parts[2]) || 0,
+    mem: parseFloat(parts[3]) || 0,
+    memKB: parseInt(parts[5], 10) || 0,
+    startTime: parts[8] || "",
+    command,
+    cwd: ""
+  };
+};
+var isClaudeLine = (line) => (line.includes("/claude") || /\bclaude\b/.test(line)) && !line.includes("grep") && !line.includes("agenttop");
+var getProcessCwd = (pid) => {
+  if (os2 === "linux") {
+    try {
+      return readlinkSync(`/proc/${pid}/cwd`);
+    } catch {
+      return "";
+    }
+  }
+  if (os2 === "darwin") {
+    try {
+      const out = execFileSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+        encoding: "utf-8",
+        timeout: 3e3
+      });
+      for (const line of out.split("\n")) {
+        if (line.startsWith("n") && line.length > 1) return line.slice(1);
+      }
+    } catch {
+    }
+    return "";
+  }
+  return "";
+};
+var getProcessCwdAsync = async (pid) => {
+  if (os2 === "linux") {
+    try {
+      return await readlink(`/proc/${pid}/cwd`);
+    } catch {
+      return "";
+    }
+  }
+  if (os2 === "darwin") {
+    return new Promise((resolve) => {
+      execFile(
+        "lsof",
+        ["-a", "-p", String(pid), "-d", "cwd", "-Fn"],
+        { encoding: "utf-8", timeout: 3e3 },
+        (err, out) => {
+          if (err || !out) {
+            resolve("");
+            return;
+          }
+          for (const line of out.split("\n")) {
+            if (line.startsWith("n") && line.length > 1) {
+              resolve(line.slice(1));
+              return;
+            }
+          }
+          resolve("");
+        }
+      );
+    });
+  }
+  return "";
+};
+var getClaudeProcessesUnix = () => {
+  try {
+    const output = execFileSync("ps", ["aux"], { encoding: "utf-8", timeout: 5e3 });
+    return output.split("\n").filter(isClaudeLine).map(parsePsLine).filter((p) => p !== null);
+  } catch {
+    return [];
+  }
+};
+var getClaudeProcessesWin32 = () => {
+  try {
+    const output = execFileSync(
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        "Get-Process | Where-Object { $_.ProcessName -match 'claude' } | Select-Object Id,CPU,WorkingSet64,Path,StartTime | ConvertTo-Json -Compress"
+      ],
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    if (!output.trim()) return [];
+    const raw = JSON.parse(output.trim());
+    const items = Array.isArray(raw) ? raw : [raw];
+    return items.filter((p) => p.Id).map((p) => ({
+      pid: Number(p.Id),
+      cpu: Number(p.CPU) || 0,
+      mem: 0,
+      memKB: Math.round((Number(p.WorkingSet64) || 0) / 1024),
+      startTime: String(p.StartTime || ""),
+      command: String(p.Path || ""),
+      cwd: ""
+    }));
+  } catch {
+    return [];
+  }
+};
 var getClaudeProcesses = () => {
+  const procs = os2 === "win32" ? getClaudeProcessesWin32() : getClaudeProcessesUnix();
+  for (const p of procs) {
+    p.cwd = getProcessCwd(p.pid);
+    p.memMB = Math.round(p.memKB / 1024);
+  }
+  return procs;
+};
+var getClaudeProcessesUnixAsync = async () => {
+  const stdout = await new Promise((resolve) => {
+    execFile("ps", ["aux"], { encoding: "utf-8", timeout: 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, out) => {
+      resolve(err || !out ? "" : out);
+    });
+  });
+  if (!stdout) return [];
+  return stdout.split("\n").filter(isClaudeLine).map(parsePsLine).filter((p) => p !== null);
+};
+var getClaudeProcessesWin32Async = async () => {
+  const stdout = await new Promise((resolve) => {
+    execFile(
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        "Get-Process | Where-Object { $_.ProcessName -match 'claude' } | Select-Object Id,CPU,WorkingSet64,Path,StartTime | ConvertTo-Json -Compress"
+      ],
+      { encoding: "utf-8", timeout: 5e3 },
+      (err, out) => resolve(err || !out ? "" : out)
+    );
+  });
+  if (!stdout.trim()) return [];
   try {
-    const output = execSync("ps aux", { encoding: "utf-8", timeout: 5e3 });
-    const procs = output.split("\n").filter((line) => line.includes("/claude") && !line.includes("grep") && !line.includes("agenttop")).map((line) => {
-      const parts = line.trim().split(/\s+/);
-      const pid = parseInt(parts[1], 10);
-      let cwd = "";
-      try {
-        cwd = readlinkSync(`/proc/${pid}/cwd`);
-      } catch {
-      }
-      return {
-        pid,
-        cpu: parseFloat(parts[2]) || 0,
-        mem: parseFloat(parts[3]) || 0,
-        memKB: parseInt(parts[5], 10) || 0,
-        startTime: parts[8] || "",
-        command: parts.slice(10).join(" "),
-        cwd
-      };
-    }).filter((p) => !isNaN(p.pid)).filter((p) => !p.command.startsWith("sudo"));
-    return procs;
+    const raw = JSON.parse(stdout.trim());
+    const items = Array.isArray(raw) ? raw : [raw];
+    return items.filter((p) => p.Id).map((p) => ({
+      pid: Number(p.Id),
+      cpu: Number(p.CPU) || 0,
+      mem: 0,
+      memKB: Math.round((Number(p.WorkingSet64) || 0) / 1024),
+      startTime: String(p.StartTime || ""),
+      command: String(p.Path || ""),
+      cwd: ""
+    }));
   } catch {
     return [];
   }
 };
+var getClaudeProcessesAsync = async () => {
+  const procs = os2 === "win32" ? await getClaudeProcessesWin32Async() : await getClaudeProcessesUnixAsync();
+  await Promise.all(
+    procs.map(async (p) => {
+      p.cwd = await getProcessCwdAsync(p.pid);
+      p.memMB = Math.round(p.memKB / 1024);
+    })
+  );
+  return procs;
+};
+
+// src/discovery/sessions.ts
 var readFirstLines = (filePath, bytes) => {
   try {
     const fd = openSync(filePath, "r");
@@ -297,6 +508,44 @@ var readFirstLines = (filePath, bytes) => {
     return [];
   }
 };
+var readTailBytes = (filePath, bytes) => {
+  try {
+    const fd = openSync(filePath, "r");
+    const fstat = statSync2(filePath);
+    const start = Math.max(0, fstat.size - bytes);
+    const readSize = Math.min(bytes, fstat.size);
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, start);
+    closeSync(fd);
+    return buf.toString("utf-8");
+  } catch {
+    return "";
+  }
+};
+var detectStatus = (filePath, hasPid, lastActivity, staleTimeout) => {
+  if (!hasPid) return "inactive";
+  const tail = readTailBytes(filePath, 4096);
+  const lines = tail.split("\n").filter(Boolean);
+  if (lines.length > 0) {
+    try {
+      const lastEvent = JSON.parse(lines[lines.length - 1]);
+      if (lastEvent.type === "assistant") {
+        const content = lastEvent.message?.content;
+        if (Array.isArray(content)) {
+          const hasAskUser = content.some(
+            (b) => b.type === "tool_use" && b.name === "AskUserQuestion"
+          );
+          if (hasAskUser) return "waiting";
+          const hasToolUse = content.some((b) => b.type === "tool_use");
+          if (!hasToolUse) return "waiting";
+        }
+      }
+    } catch {
+    }
+  }
+  if (Date.now() - lastActivity > staleTimeout * 1e3) return "stale";
+  return "active";
+};
 var readFirstEvent = (filePath) => {
   const lines = readFirstLines(filePath, 16384);
   if (lines.length === 0) return null;
@@ -362,7 +611,7 @@ var extractSessionMeta = (filePath) => {
   if (!sessionId) return null;
   return { sessionId, cwd, version, gitBranch, model, usage };
 };
-var discoverFromProjects = (allUsers, processes, sessionMap) => {
+var discoverFromProjects = (allUsers, processes, sessionMap, staleTimeout, pinnedOrder) => {
   const projectsDirs = getProjectsDirs(allUsers);
   for (const projectsDir of projectsDirs) {
     let projectNames;
@@ -415,14 +664,16 @@ var discoverFromProjects = (allUsers, processes, sessionMap) => {
           outputFiles: [filePath],
           startTime: fstat.birthtimeMs || fstat.ctimeMs,
           lastActivity: fstat.mtimeMs,
-          usage: meta.usage
+          usage: meta.usage,
+          status: detectStatus(filePath, matchingProcess !== void 0, fstat.mtimeMs, staleTimeout),
+          pinned: pinnedOrder.includes(meta.sessionId)
         };
         sessionMap.set(meta.sessionId, session);
       }
     }
   }
 };
-var discoverFromTmp = (allUsers, processes, sessionMap) => {
+var discoverFromTmp = (allUsers, processes, sessionMap, staleTimeout, pinnedOrder) => {
   const taskDirs = getTaskDirs(allUsers);
   for (const taskDir of taskDirs) {
     let projectDirs;
@@ -510,6 +761,13 @@ var discoverFromTmp = (allUsers, processes, sessionMap) => {
         if (sessionMap.has(sessionId || projectName)) continue;
         const normCwd = normalisePath(cwd);
         const matchingProcess = processes.find((p) => p.cwd && normalisePath(p.cwd) === normCwd);
+        const latestFile = outputFiles.reduce((a, b) => {
+          try {
+            return statSync2(a).mtimeMs > statSync2(b).mtimeMs ? a : b;
+          } catch {
+            return a;
+          }
+        });
         const session = {
           sessionId,
           slug: slug || sessionId.slice(0, 12),
@@ -527,7 +785,9 @@ var discoverFromTmp = (allUsers, processes, sessionMap) => {
           outputFiles,
           startTime: startTime === Infinity ? Date.now() : startTime,
           lastActivity,
-          usage: totalUsage
+          usage: totalUsage,
+          status: detectStatus(latestFile, matchingProcess !== void 0, lastActivity, staleTimeout),
+          pinned: pinnedOrder.includes(sessionId)
         };
         sessionMap.set(sessionId || projectName, session);
       }
@@ -535,22 +795,28 @@ var discoverFromTmp = (allUsers, processes, sessionMap) => {
   }
 };
 var discoverSessions = (allUsers) => {
+  const config = loadConfig();
+  const staleTimeout = config.alerts.staleTimeout ?? 60;
+  const pinnedOrder = config.pinnedSessions ?? [];
   const processes = getClaudeProcesses();
   const sessionMap = /* @__PURE__ */ new Map();
-  discoverFromProjects(allUsers, processes, sessionMap);
-  discoverFromTmp(allUsers, processes, sessionMap);
+  discoverFromProjects(allUsers, processes, sessionMap, staleTimeout, pinnedOrder);
+  discoverFromTmp(allUsers, processes, sessionMap, staleTimeout, pinnedOrder);
   return Array.from(sessionMap.values()).sort((a, b) => {
-    const aActive = a.pid !== null ? 1 : 0;
-    const bActive = b.pid !== null ? 1 : 0;
-    if (aActive !== bActive) return bActive - aActive;
+    const aPin = pinnedOrder.indexOf(a.sessionId);
+    const bPin = pinnedOrder.indexOf(b.sessionId);
+    const aIsPinned = aPin !== -1;
+    const bIsPinned = bPin !== -1;
+    if (aIsPinned && !bIsPinned) return -1;
+    if (!aIsPinned && bIsPinned) return 1;
+    if (aIsPinned && bIsPinned) return aPin - bPin;
+    const aPri = STATUS_PRIORITY[a.status];
+    const bPri = STATUS_PRIORITY[b.status];
+    if (aPri !== bPri) return aPri - bPri;
     return b.lastActivity - a.lastActivity;
   });
 };
 
-// src/discovery/types.ts
-var isToolResult = (event) => "toolUseId" in event;
-var isToolCall = (event) => "toolName" in event;
-
 // src/analysis/rules/network.ts
 var NETWORK_PATTERNS = [
   /\bcurl\b/,
@@ -763,6 +1029,51 @@ var checkToolResultInjection = (result) => {
   };
 };
 
+// src/analysis/rules/custom.ts
+var createCustomRules = (rules) => {
+  const compiled = [];
+  for (const rule of rules) {
+    if (!rule.enabled) continue;
+    let regex;
+    try {
+      regex = new RegExp(rule.pattern);
+    } catch {
+      continue;
+    }
+    const fn = (event) => {
+      let matched = false;
+      if (isToolCall(event)) {
+        if (rule.match === "output") return null;
+        if (rule.match === "toolName" || rule.match === "all") {
+          if (regex.test(event.toolName)) matched = true;
+        }
+        if (!matched && (rule.match === "input" || rule.match === "all")) {
+          if (regex.test(JSON.stringify(event.toolInput))) matched = true;
+        }
+      }
+      if (isToolResult(event)) {
+        if (rule.match === "input" || rule.match === "toolName") return null;
+        if (rule.match === "output" || rule.match === "all") {
+          if (regex.test(event.content)) matched = true;
+        }
+      }
+      if (!matched) return null;
+      return {
+        id: `custom-${rule.name}-${event.timestamp}`,
+        severity: rule.severity,
+        rule: `custom:${rule.name}`,
+        message: rule.message || rule.name,
+        sessionSlug: "slug" in event ? event.slug : "",
+        sessionId: "sessionId" in event ? event.sessionId : "",
+        event,
+        timestamp: event.timestamp
+      };
+    };
+    compiled.push(fn);
+  }
+  return compiled;
+};
+
 // src/analysis/security.ts
 var toolCallRules = [
   { key: "network", fn: checkNetwork },
@@ -782,7 +1093,8 @@ var SecurityEngine = class {
   recentAlerts = /* @__PURE__ */ new Map();
   minLevel;
   rulesConfig;
-  constructor(minLevel = "warn", rulesConfig) {
+  customEventRules = [];
+  constructor(minLevel = "warn", rulesConfig, customRules) {
     this.minLevel = minLevel;
     this.rulesConfig = rulesConfig ?? {
       network: true,
@@ -791,6 +1103,9 @@ var SecurityEngine = class {
       shellEscape: true,
       injection: true
     };
+    if (customRules?.length) {
+      this.customEventRules = createCustomRules(customRules);
+    }
   }
   analyze(call) {
     return this.analyzeEvent(call);
@@ -812,6 +1127,10 @@ var SecurityEngine = class {
       const alert = rule.fn(event);
       if (alert) alerts.push(alert);
     }
+    for (const fn of this.customEventRules) {
+      const alert = fn(event);
+      if (alert) alerts.push(alert);
+    }
     return alerts.filter((alert) => {
       if (SEVERITY_ORDER[alert.severity] < SEVERITY_ORDER[this.minLevel]) return false;
       const dedupKey = `${alert.rule}-${alert.sessionId}-${alert.message.slice(0, 40)}`;
@@ -1131,6 +1450,16 @@ var Watcher = class {
 // src/mcp/server.ts
 var MAX_ALERTS = 100;
 var MAX_ACTIVITY = 200;
+var getVersion = () => {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const pkgPath = join4(dirname(thisFile), "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
 var startMcpServer = async (allUsers, noSecurity) => {
   const alerts = [];
   const activity = /* @__PURE__ */ new Map();
@@ -1153,7 +1482,7 @@ var startMcpServer = async (allUsers, noSecurity) => {
   const watcher = new Watcher(toolHandler, allUsers, securityHandler);
   watcher.start();
   const server = new Server(
-    { name: "agenttop", version: "0.3.0" },
+    { name: "agenttop", version: getVersion() },
     {
       capabilities: { tools: {} }
     }
@@ -1201,6 +1530,79 @@ var startMcpServer = async (allUsers, noSecurity) => {
           },
           required: ["sessionId"]
         }
+      },
+      {
+        name: "agenttop_waiting_sessions",
+        description: "List sessions in waiting or stale state",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "agenttop_session_status",
+        description: "Get status for a session",
+        inputSchema: {
+          type: "object",
+          properties: { sessionId: { type: "string" } },
+          required: ["sessionId"]
+        }
+      },
+      {
+        name: "agenttop_custom_alerts",
+        description: "List custom alert rules",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "agenttop_set_custom_alert",
+        description: "Add or update a custom alert rule",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            pattern: { type: "string" },
+            match: { type: "string", enum: ["input", "output", "toolName", "all"] },
+            severity: { type: "string", enum: ["info", "warn", "high", "critical"] },
+            message: { type: "string" }
+          },
+          required: ["name", "pattern"]
+        }
+      },
+      {
+        name: "agenttop_delete_custom_alert",
+        description: "Delete a custom alert rule",
+        inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] }
+      },
+      {
+        name: "agenttop_alert_history",
+        description: "Get recent alerts with severity filter",
+        inputSchema: {
+          type: "object",
+          properties: {
+            severity: { type: "string", enum: ["info", "warn", "high", "critical"] },
+            limit: { type: "number" }
+          }
+        }
+      },
+      {
+        name: "agenttop_set_stale_timeout",
+        description: "Set stale timeout in seconds",
+        inputSchema: { type: "object", properties: { seconds: { type: "number" } }, required: ["seconds"] }
+      },
+      {
+        name: "agenttop_pin_session",
+        description: "Pin a session to top",
+        inputSchema: {
+          type: "object",
+          properties: { sessionId: { type: "string" } },
+          required: ["sessionId"]
+        }
+      },
+      {
+        name: "agenttop_unpin_session",
+        description: "Unpin a session",
+        inputSchema: {
+          type: "object",
+          properties: { sessionId: { type: "string" } },
+          required: ["sessionId"]
+        }
       }
     ]
   }));
@@ -1217,7 +1619,9 @@ var startMcpServer = async (allUsers, noSecurity) => {
           cpu: s.cpu,
           memMB: s.memMB,
           agents: s.agentCount,
-          tokens: { input: s.usage.inputTokens, output: s.usage.outputTokens, cacheRead: s.usage.cacheReadTokens }
+          tokens: { input: s.usage.inputTokens, output: s.usage.outputTokens, cacheRead: s.usage.cacheReadTokens },
+          status: s.status,
+          pinned: s.pinned
         }));
         return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
       }
@@ -1256,6 +1660,115 @@ var startMcpServer = async (allUsers, noSecurity) => {
         }));
         return { content: [{ type: "text", text: JSON.stringify(events, null, 2) }] };
       }
+      case "agenttop_waiting_sessions": {
+        const sessions = discoverSessions(allUsers);
+        const waiting = sessions.filter((s) => s.status === "waiting" || s.status === "stale").map((s) => ({
+          sessionId: s.sessionId,
+          slug: s.slug,
+          status: s.status,
+          cwd: s.cwd,
+          model: s.model,
+          idleSeconds: Math.round((Date.now() - s.lastActivity) / 1e3)
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(waiting, null, 2) }] };
+      }
+      case "agenttop_session_status": {
+        const sid = args?.sessionId;
+        const sessions = discoverSessions(allUsers);
+        const session = sessions.find((s) => s.sessionId === sid);
+        if (!session) return { content: [{ type: "text", text: `Session not found: ${sid}` }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify({ sessionId: sid, status: session.status }) }] };
+      }
+      case "agenttop_custom_alerts": {
+        const cfg = loadConfig();
+        return { content: [{ type: "text", text: JSON.stringify(cfg.alerts.custom ?? [], null, 2) }] };
+      }
+      case "agenttop_set_custom_alert": {
+        const name2 = args?.name;
+        const pattern = args?.pattern;
+        try {
+          new RegExp(pattern);
+        } catch {
+          return { content: [{ type: "text", text: `Invalid regex: ${pattern}` }], isError: true };
+        }
+        const cfg = loadConfig();
+        const custom = [...cfg.alerts.custom ?? []];
+        const existing = custom.findIndex((r) => r.name === name2);
+        const rule = {
+          name: name2,
+          pattern,
+          match: args?.match ?? "all",
+          severity: args?.severity ?? "warn",
+          message: args?.message ?? name2,
+          enabled: true
+        };
+        if (existing >= 0) custom[existing] = rule;
+        else custom.push(rule);
+        cfg.alerts.custom = custom;
+        saveConfig(cfg);
+        return { content: [{ type: "text", text: `Rule '${name2}' saved` }] };
+      }
+      case "agenttop_delete_custom_alert": {
+        const name2 = args?.name;
+        const cfg = loadConfig();
+        cfg.alerts.custom = (cfg.alerts.custom ?? []).filter((r) => r.name !== name2);
+        saveConfig(cfg);
+        return { content: [{ type: "text", text: `Rule '${name2}' deleted` }] };
+      }
+      case "agenttop_alert_history": {
+        const severity = args?.severity ?? "info";
+        const limit = args?.limit ?? 50;
+        const order = { info: 0, warn: 1, high: 2, critical: 3 };
+        const minOrder = order[severity] ?? 0;
+        const cfg = loadConfig();
+        const logPath = resolveAlertLogPath(cfg);
+        const logAlerts = [];
+        try {
+          const lines = readFileSync2(logPath, "utf-8").split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const a = JSON.parse(line);
+              if ((order[a.severity] ?? 0) >= minOrder)
+                logAlerts.push({
+                  severity: a.severity,
+                  rule: a.rule,
+                  message: a.message,
+                  sessionSlug: a.sessionSlug,
+                  timestamp: a.timestamp ? new Date(a.timestamp).toISOString() : "unknown"
+                });
+            } catch {
+              continue;
+            }
+          }
+        } catch {
+        }
+        for (const a of alerts) {
+          if ((order[a.severity] ?? 0) >= minOrder)
+            logAlerts.push({
+              severity: a.severity,
+              rule: a.rule,
+              message: a.message,
+              sessionSlug: a.sessionSlug,
+              timestamp: new Date(a.timestamp).toISOString()
+            });
+        }
+        return { content: [{ type: "text", text: JSON.stringify(logAlerts.slice(-limit), null, 2) }] };
+      }
+      case "agenttop_set_stale_timeout": {
+        const seconds = Math.max(15, args?.seconds ?? 60);
+        const cfg = loadConfig();
+        cfg.alerts.staleTimeout = seconds;
+        saveConfig(cfg);
+        return { content: [{ type: "text", text: `Stale timeout set to ${seconds}s` }] };
+      }
+      case "agenttop_pin_session": {
+        pinSession(args?.sessionId);
+        return { content: [{ type: "text", text: `Session pinned` }] };
+      }
+      case "agenttop_unpin_session": {
+        unpinSession(args?.sessionId);
+        return { content: [{ type: "text", text: `Session unpinned` }] };
+      }
       default:
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
     }
@@ -1286,11 +1799,16 @@ export {
   getArchived,
   purgeExpiredArchives,
   deleteSessionFiles,
+  pinSession,
+  unpinSession,
+  movePinned,
   getTaskDirs,
   getProjectsDirs,
+  STATUS_PRIORITY,
+  getClaudeProcessesAsync,
   Watcher,
   SecurityEngine,
   discoverSessions,
   startMcpServer
 };
-//# sourceMappingURL=chunk-24HX2MSZ.js.map
+//# sourceMappingURL=chunk-LPXME2WB.js.map