@agents-tower/core 0.1.0

package/dist/hermes.js

@@ -0,0 +1,2446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHermesProjectSnapshotData = loadHermesProjectSnapshotData;
+exports.discoverHermesProjects = discoverHermesProjects;
+exports.loadRoamingHermesSnapshotData = loadRoamingHermesSnapshotData;
+exports.summarizeHermesSessionForTest = summarizeHermesSessionForTest;
+exports.summarizeHermesHookSessionForTest = summarizeHermesHookSessionForTest;
+exports.isHermesGatewayDaemonForTest = isHermesGatewayDaemonForTest;
+exports.isHermesRuntimeHomeProcessForTest = isHermesRuntimeHomeProcessForTest;
+exports.isHermesCompressionContinuationForTest = isHermesCompressionContinuationForTest;
+exports.currentHermesSessionProjectRootForTest = currentHermesSessionProjectRootForTest;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
+const node_util_1 = require("node:util");
+const appearance_1 = require("./appearance");
+const hermes_hook_install_1 = require("./hermes-hook-install");
+const project_paths_1 = require("./project-paths");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const DEFAULT_HERMES_SESSION_LIMIT = 12;
+const HERMES_SESSION_SCAN_LIMIT = 30;
+const HERMES_PROJECT_DISCOVERY_HOOK_WINDOW_MS = 2 * 60 * 60 * 1000;
+const HERMES_RECENT_DONE_WINDOW_MS = 5 * 60 * 1000;
+const HERMES_RECENT_OPEN_WINDOW_MS = 20 * 60 * 1000;
+const HERMES_SQLITE_MESSAGE_LIMIT = 10;
+const HERMES_SQLITE_TEXT_LIMIT = 2000;
+const HERMES_SQLITE_TIMEOUT_MS = 5000;
+const HERMES_SQLITE_MAX_BUFFER = 8 * 1024 * 1024;
+const HERMES_HOOK_FILE_BYTE_LIMIT = 1024 * 1024;
+const HERMES_HOOK_LINE_BYTE_LIMIT = 64 * 1024;
+const HERMES_HOOK_RECORD_LIMIT = 80;
+// Keep a project relation through 20 rootless hook actions, then treat the stream as projectless.
+const HERMES_PROJECT_RELATION_ACTION_WINDOW = 21;
+const HERMES_HOOK_TEXT_LIMIT = 1500;
+const HERMES_HOOK_PATH_LIMIT = 32;
+const HERMES_TRANSIENT_PROJECT_ROOTS = new Set(["/tmp", "/var/tmp", "/dev/shm"]);
+const HERMES_CRON_SESSION_ID_RE = /^cron_[A-Za-z0-9_-]+_\d{8}_\d{6}$/i;
+function hermesLocalSessionLimit() {
+    const raw = Number.parseInt(process.env.HERMES_LOCAL_SESSION_LIMIT ?? "", 10);
+    if (!Number.isFinite(raw)) {
+        return DEFAULT_HERMES_SESSION_LIMIT;
+    }
+    return Math.max(1, Math.min(50, raw));
+}
+function hermesScanLimit(limit) {
+    return Math.max(1, Math.min(HERMES_SESSION_SCAN_LIMIT, limit));
+}
+async function looksLikeHermesRuntimeProjectRoot(root) {
+    const normalized = root.replace(/\\/g, "/").toLowerCase();
+    if (!normalized.endsWith("/hermes-agent")) {
+        return false;
+    }
+    return await pathExists((0, node_path_1.join)(root, "hermes_cli", "main.py"))
+        && await pathExists((0, node_path_1.join)(root, "gateway"))
+        && await pathExists((0, node_path_1.join)(root, "pyproject.toml"));
+}
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(hostFilesystemPath(path), node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function expandHomePath(path) {
+    const trimmed = path.trim();
+    if (trimmed === "~") {
+        return (0, node_os_1.homedir)();
+    }
+    if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), trimmed.slice(2));
+    }
+    return trimmed;
+}
+function normalizeFilesystemPath(path) {
+    if (typeof path !== "string" || path.trim().length === 0) {
+        return null;
+    }
+    return (0, project_paths_1.canonicalizeProjectPath)(expandHomePath(path)) ?? null;
+}
+function hostFilesystemPath(path) {
+    const canonical = (0, project_paths_1.canonicalizeProjectPath)(path) ?? path;
+    const match = canonical.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+    if (node_process_1.platform !== "win32" || !match) {
+        return path;
+    }
+    const drive = match[1].toUpperCase();
+    const rest = match[2].replace(/\//g, "\\");
+    return `${drive}:\\${rest}`;
+}
+function hermesHookDirectories() {
+    const explicit = normalizeFilesystemPath(process.env.CODEX_AGENTS_OFFICE_HERMES_HOOK_DIR);
+    if (explicit) {
+        return [explicit];
+    }
+    const dirs = [];
+    const seen = new Set();
+    const add = (path) => {
+        const normalized = normalizeFilesystemPath(path);
+        const key = (0, project_paths_1.projectPathIdentityKey)(normalized);
+        if (!normalized || !key || seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        dirs.push(normalized);
+    };
+    add((0, hermes_hook_install_1.getHermesHooksDir)());
+    add((0, node_path_1.join)((0, node_os_1.homedir)(), ".codex", "codex-agents-office", "hermes-hooks"));
+    return dirs;
+}
+async function hermesHomeCandidatesFromDisk() {
+    const roots = new Set();
+    const explicitHome = normalizeFilesystemPath(process.env.HERMES_HOME);
+    if (explicitHome) {
+        roots.add(explicitHome);
+    }
+    const defaultRoot = normalizeFilesystemPath((0, node_path_1.join)((0, node_os_1.homedir)(), ".hermes"));
+    if (defaultRoot) {
+        roots.add(defaultRoot);
+    }
+    const rootCandidates = [...roots];
+    for (const root of rootCandidates) {
+        const profilesDir = (0, node_path_1.join)(root, "profiles");
+        const profiles = await (0, promises_1.readdir)(hostFilesystemPath(profilesDir), { withFileTypes: true }).catch(() => []);
+        for (const entry of profiles) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const profileHome = normalizeFilesystemPath((0, node_path_1.join)(profilesDir, entry.name));
+            if (profileHome) {
+                roots.add(profileHome);
+            }
+        }
+    }
+    const explicitStateDb = normalizeFilesystemPath(process.env.HERMES_STATE_DB);
+    if (explicitStateDb) {
+        roots.add((0, node_path_1.resolve)(explicitStateDb, ".."));
+    }
+    return [...roots];
+}
+async function readProcFile(path) {
+    try {
+        return await (0, promises_1.readFile)(path);
+    }
+    catch {
+        return null;
+    }
+}
+function splitNulFile(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .toString("utf8")
+        .split("\0")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function parseProcEnviron(raw) {
+    const env = {};
+    for (const entry of splitNulFile(raw)) {
+        const equalsIndex = entry.indexOf("=");
+        if (equalsIndex <= 0) {
+            continue;
+        }
+        env[entry.slice(0, equalsIndex)] = entry.slice(equalsIndex + 1);
+    }
+    return env;
+}
+function looksLikeHermesProcess(argv) {
+    if (argv.length === 0) {
+        return false;
+    }
+    return argv.some((arg) => {
+        const normalized = arg.replace(/\\/g, "/").toLowerCase();
+        const base = (0, node_path_1.basename)(normalized);
+        return base === "hermes"
+            || base === "hermes.exe"
+            || base === "hermes.cmd"
+            || normalized.endsWith("/hermes_cli/main.py")
+            || normalized.endsWith("/gateway/run.py")
+            || normalized.endsWith("/run_agent.py")
+            || (normalized.endsWith("/cli.py") && normalized.includes("hermes"));
+    });
+}
+function looksLikeHermesGatewayDaemon(argv) {
+    const normalized = argv.map((arg) => arg.replace(/\\/g, "/").toLowerCase());
+    const usesHermesEntrypoint = normalized.some((arg) => {
+        const base = (0, node_path_1.basename)(arg);
+        return base === "hermes"
+            || base === "hermes.exe"
+            || base === "hermes.cmd"
+            || arg.endsWith("/hermes_cli/main.py")
+            || arg === "hermes_cli.main";
+    });
+    return usesHermesEntrypoint
+        && normalized.includes("gateway")
+        && normalized.includes("run");
+}
+function looksLikeHermesRuntimeHomeProcess(argv, cwd) {
+    const normalizedCwd = (cwd ?? "").replace(/\\/g, "/").toLowerCase();
+    if (!normalizedCwd.endsWith("/hermes-agent")) {
+        return false;
+    }
+    const normalized = argv.map((arg) => arg.replace(/\\/g, "/").toLowerCase());
+    const launcherIndex = normalized.findIndex((arg) => {
+        const base = (0, node_path_1.basename)(arg);
+        return base === "hermes"
+            || base === "hermes.exe"
+            || base === "hermes.cmd";
+    });
+    return launcherIndex >= 0 && launcherIndex === normalized.length - 1;
+}
+async function scanHermesProcesses() {
+    if (process.platform !== "linux") {
+        return [];
+    }
+    const procEntries = await (0, promises_1.readdir)("/proc", { withFileTypes: true }).catch(() => []);
+    const processes = [];
+    for (const entry of procEntries) {
+        if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) {
+            continue;
+        }
+        const pid = Number.parseInt(entry.name, 10);
+        if (!Number.isFinite(pid) || pid === process.pid) {
+            continue;
+        }
+        const procRoot = (0, node_path_1.join)("/proc", entry.name);
+        const argv = splitNulFile(await readProcFile((0, node_path_1.join)(procRoot, "cmdline")));
+        const env = parseProcEnviron(await readProcFile((0, node_path_1.join)(procRoot, "environ")));
+        if (looksLikeHermesGatewayDaemon(argv)) {
+            continue;
+        }
+        if (!looksLikeHermesProcess(argv)) {
+            continue;
+        }
+        const cwd = await (0, promises_1.readlink)((0, node_path_1.join)(procRoot, "cwd")).catch(() => null);
+        const normalizedCwd = normalizeFilesystemPath(env.TERMINAL_CWD)
+            ?? normalizeFilesystemPath(env.HERMES_CWD)
+            ?? normalizeFilesystemPath(cwd);
+        if (looksLikeHermesRuntimeHomeProcess(argv, normalizedCwd)) {
+            continue;
+        }
+        const normalizedHome = normalizeFilesystemPath(env.HERMES_HOME);
+        const procStats = await (0, promises_1.stat)(procRoot).catch(() => null);
+        processes.push({
+            pid,
+            cwd: normalizedCwd,
+            hermesHome: normalizedHome,
+            command: argv.join(" "),
+            updatedAtMs: procStats?.mtimeMs ?? Date.now()
+        });
+    }
+    return processes;
+}
+function pythonCandidates() {
+    const candidates = [
+        process.env.HERMES_SQLITE_PYTHON,
+        "python3",
+        "python"
+    ].filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    return Array.from(new Set(candidates));
+}
+const HERMES_SQLITE_EXPORT_SCRIPT = `
+import json
+import sqlite3
+import sys
+import urllib.parse
+
+db_path = sys.argv[1]
+limit = int(sys.argv[2])
+message_limit = int(sys.argv[3])
+text_limit = int(sys.argv[4])
+uri = "file:" + urllib.parse.quote(db_path) + "?mode=ro"
+conn = sqlite3.connect(uri, uri=True, timeout=1.0)
+conn.row_factory = sqlite3.Row
+conn.execute("PRAGMA busy_timeout=1000")
+sessions = conn.execute("""
+  SELECT
+    s.id,
+    substr(s.source, 1, ?) AS source,
+    substr(s.model, 1, ?) AS model,
+    s.parent_session_id,
+    p.ended_at AS parent_ended_at,
+    substr(p.end_reason, 1, ?) AS parent_end_reason,
+    s.started_at,
+    s.ended_at,
+    substr(s.end_reason, 1, ?) AS end_reason,
+    s.message_count,
+    s.tool_call_count,
+    substr(s.title, 1, ?) AS title,
+    substr(s.system_prompt, 1, ?) AS system_prompt,
+    COALESCE((SELECT MAX(m.timestamp) FROM messages m WHERE m.session_id = s.id), s.started_at) AS last_active
+  FROM sessions s
+  LEFT JOIN sessions p ON p.id = s.parent_session_id
+  ORDER BY last_active DESC
+  LIMIT ?
+""", (text_limit, text_limit, text_limit, text_limit, text_limit, text_limit, limit)).fetchall()
+
+result = []
+for session in sessions:
+    messages = conn.execute("""
+      SELECT
+        id,
+        role,
+        substr(content, 1, ?) AS content,
+        substr(tool_calls, 1, ?) AS tool_calls,
+        tool_name,
+        tool_call_id,
+        timestamp,
+        finish_reason,
+        NULL AS reasoning,
+        NULL AS reasoning_content
+      FROM messages
+      WHERE session_id = ?
+      ORDER BY timestamp DESC, id DESC
+      LIMIT ?
+    """, (text_limit, text_limit, session["id"], message_limit)).fetchall()
+    result.append({
+      "id": session["id"],
+      "source": session["source"],
+      "model": session["model"],
+      "parentSessionId": session["parent_session_id"],
+      "parentEndedAt": session["parent_ended_at"],
+      "parentEndReason": session["parent_end_reason"],
+      "startedAt": session["started_at"],
+      "endedAt": session["ended_at"],
+      "endReason": session["end_reason"],
+      "messageCount": session["message_count"],
+      "toolCallCount": session["tool_call_count"],
+      "title": session["title"],
+      "systemPrompt": session["system_prompt"],
+      "lastActive": session["last_active"],
+      "messages": [dict(row) for row in reversed(messages)],
+    })
+print(json.dumps({"sessions": result}, ensure_ascii=False))
+`;
+async function exportHermesSqlite(dbPath, limit) {
+    let lastError = null;
+    for (const python of pythonCandidates()) {
+        try {
+            const { stdout } = await execFileAsync(python, ["-c", HERMES_SQLITE_EXPORT_SCRIPT, dbPath, String(limit), String(HERMES_SQLITE_MESSAGE_LIMIT), String(HERMES_SQLITE_TEXT_LIMIT)], {
+                timeout: HERMES_SQLITE_TIMEOUT_MS,
+                maxBuffer: HERMES_SQLITE_MAX_BUFFER
+            });
+            return JSON.parse(stdout);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            const code = typeof error === "object" && error !== null && "code" in error
+                ? String(error.code)
+                : "";
+            if (code !== "ENOENT") {
+                break;
+            }
+        }
+    }
+    throw lastError ?? new Error("No Python executable available for Hermes SQLite reads");
+}
+function normalizeSqliteMessage(raw) {
+    return {
+        id: typeof raw.id === "number" || typeof raw.id === "string" ? raw.id : "",
+        role: typeof raw.role === "string" ? raw.role : null,
+        content: raw.content,
+        toolCalls: raw.tool_calls,
+        toolName: typeof raw.tool_name === "string" ? raw.tool_name : null,
+        toolCallId: typeof raw.tool_call_id === "string" ? raw.tool_call_id : null,
+        timestamp: typeof raw.timestamp === "number" ? raw.timestamp : 0,
+        finishReason: typeof raw.finish_reason === "string" ? raw.finish_reason : null,
+        reasoning: typeof raw.reasoning === "string" ? raw.reasoning : null,
+        reasoningContent: typeof raw.reasoning_content === "string" ? raw.reasoning_content : null
+    };
+}
+async function loadHermesSqliteSessions(home, limit) {
+    const explicitDb = normalizeFilesystemPath(process.env.HERMES_STATE_DB);
+    const dbPath = explicitDb ?? (0, node_path_1.join)(home, "state.db");
+    if (!await pathExists(dbPath)) {
+        return [];
+    }
+    const exported = await exportHermesSqlite(hostFilesystemPath(dbPath), limit);
+    return exported.sessions.map((session) => ({
+        ...session,
+        startedAt: Number(session.startedAt) || 0,
+        endedAt: typeof session.endedAt === "number" && Number.isFinite(session.endedAt) && session.endedAt > 0
+            ? session.endedAt
+            : null,
+        parentEndedAt: typeof session.parentEndedAt === "number" && Number.isFinite(session.parentEndedAt) && session.parentEndedAt > 0
+            ? session.parentEndedAt
+            : null,
+        parentEndReason: typeof session.parentEndReason === "string" ? session.parentEndReason : null,
+        messageCount: Number(session.messageCount) || 0,
+        toolCallCount: Number(session.toolCallCount) || 0,
+        systemPrompt: typeof session.systemPrompt === "string" ? session.systemPrompt : null,
+        lastActive: Number(session.lastActive) || Number(session.startedAt) || 0,
+        home,
+        storage: "sqlite",
+        messages: session.messages.map((message) => normalizeSqliteMessage(message))
+    }));
+}
+async function loadHermesSessions(home, limit, notes) {
+    try {
+        const sqliteSessions = await loadHermesSqliteSessions(home, limit);
+        return sqliteSessions;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        notes.push(`Hermes SQLite sessions unavailable for ${home}: ${message}`);
+        return [];
+    }
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || !/^[{[]/.test(trimmed)) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function textFromContent(value) {
+    const parsed = parseMaybeJson(value);
+    if (typeof parsed === "string") {
+        return parsed.replace(/\s+/g, " ").trim();
+    }
+    if (Array.isArray(parsed)) {
+        return parsed
+            .map((entry) => {
+            if (typeof entry === "string") {
+                return entry;
+            }
+            if (entry && typeof entry === "object" && "text" in entry) {
+                return String(entry.text ?? "");
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    if (parsed && typeof parsed === "object") {
+        const object = parsed;
+        for (const key of ["output", "error", "content", "message", "text"]) {
+            const candidate = object[key];
+            if (typeof candidate === "string" && candidate.trim()) {
+                return candidate.replace(/\s+/g, " ").trim();
+            }
+        }
+    }
+    return "";
+}
+function shorten(text, maxLength) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function parseToolCalls(value) {
+    const parsed = parseMaybeJson(value);
+    const list = Array.isArray(parsed) ? parsed : parsed ? [parsed] : [];
+    const calls = [];
+    for (const entry of list) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const record = entry;
+        const functionRecord = record.function && typeof record.function === "object"
+            ? record.function
+            : null;
+        const name = typeof record.name === "string"
+            ? record.name
+            : typeof functionRecord?.name === "string"
+                ? functionRecord.name
+                : typeof record.tool_name === "string"
+                    ? record.tool_name
+                    : "";
+        const rawArgs = record.arguments ?? functionRecord?.arguments ?? record.args ?? {};
+        const args = parseMaybeJson(rawArgs);
+        calls.push({
+            name,
+            args: args && typeof args === "object" && !Array.isArray(args)
+                ? args
+                : {}
+        });
+    }
+    return calls.filter((call) => call.name.length > 0);
+}
+function latestAssistantText(messages) {
+    for (const message of [...messages].reverse()) {
+        if (message.role !== "assistant") {
+            continue;
+        }
+        const text = textFromContent(message.content);
+        if (text) {
+            return shorten(text, 240);
+        }
+    }
+    return null;
+}
+function latestUserContent(messages) {
+    for (const message of [...messages].reverse()) {
+        if (message.role !== "user") {
+            continue;
+        }
+        const text = textFromContent(message.content);
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function hermesProjectDisplayLabel(projectRoot) {
+    const label = (0, project_paths_1.projectLabelFromRoot)(projectRoot) || "Hermes";
+    return label === "Ika Bot" ? "IkaBot" : label;
+}
+function titleCaseHermesWord(word) {
+    const lower = word.toLowerCase();
+    if (lower === "ikabot") {
+        return "IkaBot";
+    }
+    if (["api", "cli", "ui", "sdk", "mcp"].includes(lower)) {
+        return lower.toUpperCase();
+    }
+    return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+function humanizeHermesSkillName(skillName) {
+    const normalized = skillName
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        return "";
+    }
+    return normalized.split(" ").map(titleCaseHermesWord).join(" ");
+}
+function hermesSkillNameFromText(text) {
+    const invoked = text.match(/invoked the "([^"]+)" skill/i)?.[1];
+    if (invoked && invoked.trim()) {
+        return invoked.trim();
+    }
+    const frontmatter = text.match(/^name:\s*([A-Za-z0-9_-]+)\s*$/m)?.[1];
+    return frontmatter && frontmatter.trim() ? frontmatter.trim() : null;
+}
+function hermesTitleFromText(text, maxLength = 54) {
+    let normalized = text
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        return null;
+    }
+    const skillName = hermesSkillNameFromText(normalized);
+    if (skillName) {
+        return shorten(humanizeHermesSkillName(skillName), maxLength);
+    }
+    normalized = normalized
+        .replace(/^got it\s*[-:\u2014]\s*/i, "")
+        .replace(/^done\s*[-:\u2014]\s*/i, "")
+        .replace(/^updated\s*[-:\u2014]\s*/i, "Updated: ")
+        .replace(/^\s*[-*]\s+/, "");
+    const firstBoundary = [
+        normalized.indexOf(" - "),
+        normalized.indexOf(" \u2014 "),
+        normalized.indexOf(". "),
+        normalized.indexOf("; ")
+    ].filter((index) => index > 12);
+    const boundary = firstBoundary.length > 0 ? Math.min(...firstBoundary) : -1;
+    let title = boundary > 0 ? normalized.slice(0, boundary) : normalized;
+    title = title.replace(/^[a-z]/, (letter) => letter.toUpperCase());
+    return shorten(title.replace(/\s+/g, " ").trim(), maxLength) || null;
+}
+function hermesTitleLooksGenericPrompt(title) {
+    return /^review the conversation above\b/i.test(title)
+        || /^continue\b/i.test(title)
+        || /^please continue\b/i.test(title);
+}
+function isHermesCronSessionId(sessionId) {
+    return HERMES_CRON_SESSION_ID_RE.test(sessionId);
+}
+function isHermesCronSession(session) {
+    const source = (session.source ?? "").trim().toLowerCase();
+    return isHermesCronSessionId(session.id) || source === "cron";
+}
+function hermesCronPromptText(text) {
+    let normalized = text
+        .replace(/^\[IMPORTANT:\s*You are running as a scheduled cron job\.[\s\S]*?\]\s*/i, "")
+        .replace(/^Cronjob Response:[\s\S]*?-------------\s*/i, "")
+        .trim();
+    if (!normalized || normalized === "[SILENT]") {
+        return null;
+    }
+    normalized = normalized.replace(/^#\s*Cron Job:\s*/i, "").trim();
+    return normalized || null;
+}
+function latestHermesSessionUserText(session, maxLength = 160) {
+    const text = latestUserContent(session.messages);
+    if (!text) {
+        return null;
+    }
+    const displayText = isHermesCronSession(session) ? hermesCronPromptText(text) : text;
+    return displayText ? shorten(displayText, maxLength) : null;
+}
+function hermesFallbackSessionLabel(projectRoot, sessionId) {
+    const projectLabel = hermesProjectDisplayLabel(projectRoot);
+    if (isHermesCronSessionId(sessionId)) {
+        return `${projectLabel} tick`;
+    }
+    return `${projectLabel} Hermes`;
+}
+function hermesHookSessionLabel(records, projectRoot, latestMessage) {
+    const latest = records[records.length - 1];
+    const sessionId = latest?.sessionId ?? "";
+    if (isHermesCronSessionId(sessionId)) {
+        return hermesFallbackSessionLabel(projectRoot, sessionId);
+    }
+    const messageTitle = latestMessage ? hermesTitleFromText(latestMessage) : null;
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+        const record = records[index];
+        const userText = hermesHookText(record, ["user_message"]);
+        const userTitle = userText ? hermesTitleFromText(userText) : null;
+        if (userTitle) {
+            if (messageTitle && hermesTitleLooksGenericPrompt(userTitle)) {
+                return messageTitle;
+            }
+            return userTitle;
+        }
+    }
+    if (messageTitle) {
+        return messageTitle;
+    }
+    return hermesFallbackSessionLabel(projectRoot, sessionId);
+}
+function toolKind(toolName) {
+    const normalized = toolName.toLowerCase();
+    if (normalized === "todo") {
+        return { state: "planning", eventType: "plan", eventKind: "turn" };
+    }
+    if (normalized === "terminal"
+        || normalized === "process"
+        || normalized === "execute_code"
+        || normalized.includes("shell")
+        || normalized.includes("bash")) {
+        return { state: "running", eventType: "commandExecution", eventKind: "command" };
+    }
+    if (normalized.startsWith("mcp_")) {
+        return { state: "running", eventType: "mcpToolCall", eventKind: "tool" };
+    }
+    if (normalized === "write_file" || normalized === "patch") {
+        return { state: "editing", eventType: "fileChange", eventKind: "fileChange" };
+    }
+    if (normalized.includes("delegate") || normalized.includes("subagent")) {
+        return { state: "delegating", eventType: "collabAgentToolCall", eventKind: "subagent" };
+    }
+    if (normalized === "web_search" || normalized.includes("browser_search")) {
+        return { state: "scanning", eventType: "webSearch", eventKind: "tool" };
+    }
+    if (normalized === "read_file"
+        || normalized === "search_files"
+        || normalized === "skills_list"
+        || normalized === "skill_view"
+        || normalized === "web_extract"
+        || normalized.includes("search")
+        || normalized.includes("read")
+        || normalized.includes("list")) {
+        return { state: "scanning", eventType: "dynamicToolCall", eventKind: "tool" };
+    }
+    return { state: "running", eventType: "dynamicToolCall", eventKind: "tool" };
+}
+function toolTitle(toolName, args) {
+    if (toolName === "terminal" && typeof args.command === "string") {
+        return shorten(args.command, 120);
+    }
+    if (toolName === "process") {
+        const action = typeof args.action === "string" && args.action.trim() ? args.action.trim() : "manage";
+        const sessionId = typeof args.session_id === "string" && args.session_id.trim()
+            ? ` ${shorten(args.session_id.trim(), 40)}`
+            : "";
+        return `process ${action}${sessionId}`;
+    }
+    if (toolName === "todo") {
+        const todos = Array.isArray(args.todos) ? args.todos : null;
+        if (!todos) {
+            return "todo: reading task list";
+        }
+        return `todo: ${args.merge === true ? "updating" : "planning"} ${todos.length} task(s)`;
+    }
+    for (const key of ["path", "file_path", "filepath", "workdir", "query", "pattern", "name", "category"]) {
+        if (typeof args[key] === "string" && String(args[key]).trim()) {
+            return `${toolName}: ${shorten(String(args[key]), 90)}`;
+        }
+    }
+    return toolName;
+}
+function toolPath(projectRoot, cwd, args) {
+    for (const key of ["path", "file_path", "filepath", "workdir", "cwd", "dir", "directory"]) {
+        const value = args[key];
+        if (typeof value !== "string" || value.trim().length === 0) {
+            continue;
+        }
+        const normalized = normalizeCandidatePath(value, cwd ?? projectRoot);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return null;
+}
+function hermesHookChangedPaths(record, projectRoot) {
+    const value = record.payload.changed_paths;
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const paths = [];
+    for (const entry of value) {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            continue;
+        }
+        const normalized = normalizeCandidatePath(entry, record.cwd ?? record.processCwd ?? projectRoot);
+        if (normalized && !paths.includes(normalized)) {
+            paths.push(normalized);
+        }
+        if (paths.length >= HERMES_HOOK_PATH_LIMIT) {
+            break;
+        }
+    }
+    return paths;
+}
+function hermesHookPreVerifyDetail(record, projectRoot) {
+    const paths = hermesHookChangedPaths(record, projectRoot);
+    const changedCount = paths.length;
+    const pathDetail = changedCount === 1
+        ? `Verifying ${(0, node_path_1.basename)(paths[0])}`
+        : changedCount > 1
+            ? `Verifying ${changedCount} changed files`
+            : "Hermes verification gate";
+    const attempt = hermesHookPayloadNumber(record, "attempt");
+    return attempt && attempt > 0 ? `${pathDetail} (attempt ${attempt + 1})` : pathDetail;
+}
+function toolActivityEvent(projectRoot, cwd, call) {
+    const kind = toolKind(call.name);
+    const path = toolPath(projectRoot, cwd, call.args);
+    return {
+        type: kind.eventType,
+        action: kind.eventKind === "command" ? "ran"
+            : kind.eventKind === "fileChange" ? "edited"
+                : "updated",
+        path,
+        title: toolTitle(call.name, call.args),
+        isImage: false
+    };
+}
+function messageLooksFailed(message) {
+    const parsed = parseMaybeJson(message.content);
+    if (parsed && typeof parsed === "object") {
+        const record = parsed;
+        if (typeof record.exit_code === "number" && record.exit_code !== 0) {
+            return true;
+        }
+        if (typeof record.returncode === "number" && record.returncode !== 0) {
+            return true;
+        }
+        if (typeof record.error === "string" && record.error.trim().length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function latestMessageToolCall(message) {
+    if (!message) {
+        return null;
+    }
+    const calls = parseToolCalls(message.toolCalls);
+    if (calls.length > 0) {
+        return calls[calls.length - 1];
+    }
+    return null;
+}
+function normalizeCandidatePath(value, cwd) {
+    const cleaned = value
+        .trim()
+        .replace(/^["'`]+|["'`),.;:]+$/g, "");
+    if (!cleaned || cleaned.length > 400) {
+        return null;
+    }
+    const absolute = /^([a-zA-Z]:[\\/]|\/)/.test(cleaned)
+        ? cleaned
+        : cleaned.startsWith("./") || cleaned.startsWith("../")
+            ? (0, node_path_1.join)(cwd, cleaned)
+            : null;
+    return normalizeFilesystemPath(absolute);
+}
+function extractAbsolutePathCandidates(text) {
+    const matches = text.match(/(?:[a-zA-Z]:[\\/][^\s"'`<>]+|\/(?:mnt\/[a-zA-Z]|home|Users|workspace|tmp|var|opt|srv)\/[^\s"'`<>]+)/g);
+    return matches ?? [];
+}
+function cwdFromSystemPrompt(systemPrompt) {
+    if (!systemPrompt) {
+        return null;
+    }
+    for (const pattern of [
+        /^Current working directory:\s*(.+)$/im,
+        /^Working directory:\s*(.+)$/im,
+        /^cwd\s*[:=]\s*(.+)$/im
+    ]) {
+        const match = systemPrompt.match(pattern);
+        if (!match) {
+            continue;
+        }
+        const value = match[1]
+            .trim()
+            .split(/\s+/)[0]
+            ?.replace(/^["'`]+|["'`),.;:]+$/g, "");
+        const normalized = normalizeFilesystemPath(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return null;
+}
+function collectSessionPathCandidates(session, fallbackCwd) {
+    const paths = new Set();
+    const promptCwd = cwdFromSystemPrompt(session.systemPrompt);
+    if (promptCwd) {
+        paths.add(promptCwd);
+    }
+    for (const message of session.messages) {
+        for (const candidate of collectMessagePathCandidates(message, fallbackCwd)) {
+            paths.add(candidate);
+        }
+    }
+    if (fallbackCwd) {
+        paths.add(fallbackCwd);
+    }
+    return [...paths];
+}
+function collectMessagePathCandidates(message, fallbackCwd) {
+    const paths = new Set();
+    for (const call of parseToolCalls(message.toolCalls)) {
+        const fromTool = toolPath("/", fallbackCwd, call.args);
+        if (fromTool) {
+            paths.add(fromTool);
+        }
+        for (const candidate of extractAbsolutePathCandidates(JSON.stringify(call.args))) {
+            const normalized = normalizeCandidatePath(candidate, fallbackCwd ?? "/");
+            if (normalized) {
+                paths.add(normalized);
+            }
+        }
+    }
+    const text = textFromContent(message.content);
+    for (const candidate of extractAbsolutePathCandidates(text)) {
+        const normalized = normalizeCandidatePath(candidate, fallbackCwd ?? "/");
+        if (normalized) {
+            paths.add(normalized);
+        }
+    }
+    return [...paths];
+}
+function sortedLatestMessages(messages) {
+    return messages
+        .map((message, index) => ({ message, index }))
+        .sort((left, right) => {
+        const timeDelta = right.message.timestamp - left.message.timestamp;
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        return right.index - left.index;
+    })
+        .map((entry) => entry.message);
+}
+async function currentProjectRootForHermesSession(session, activeProcess) {
+    if (activeProcess?.cwd) {
+        const activeRoot = await resolveProjectRootForPath(activeProcess.cwd);
+        if (activeRoot) {
+            return activeRoot;
+        }
+    }
+    const sessionCwd = cwdFromSystemPrompt(session.systemPrompt);
+    for (const message of sortedLatestMessages(session.messages)) {
+        for (const candidate of collectMessagePathCandidates(message, sessionCwd)) {
+            const root = await resolveProjectRootForPath(candidate);
+            if (root) {
+                return root;
+            }
+        }
+    }
+    if (sessionCwd) {
+        return resolveProjectRootForPath(sessionCwd);
+    }
+    return null;
+}
+function pathWithinProject(projectRoot, candidate) {
+    if (!candidate) {
+        return false;
+    }
+    if ((0, project_paths_1.sameProjectPath)(projectRoot, candidate)) {
+        return true;
+    }
+    const rootKey = (0, project_paths_1.projectPathIdentityKey)(projectRoot);
+    const candidateKey = (0, project_paths_1.projectPathIdentityKey)(candidate);
+    return Boolean(rootKey && candidateKey && candidateKey.startsWith(`${rootKey}/`));
+}
+async function resolveProjectRootForPath(path) {
+    const normalized = normalizeFilesystemPath(path);
+    if (!normalized) {
+        return null;
+    }
+    const statResult = await (0, promises_1.stat)(hostFilesystemPath(normalized)).catch(() => null);
+    let current = statResult && statResult.isDirectory() ? normalized : (0, node_path_1.dirname)(normalized);
+    current = (0, project_paths_1.canonicalizeProjectPath)(current) ?? current;
+    while (current && current !== (0, node_path_1.dirname)(current)) {
+        if (await pathExists((0, node_path_1.join)(current, ".git"))) {
+            return current;
+        }
+        current = (0, node_path_1.dirname)(current);
+    }
+    return statResult ? (0, project_paths_1.canonicalizeProjectPath)(normalized) : null;
+}
+function sessionLabel(session, projectRoot) {
+    if (session.title && session.title.trim()) {
+        return shorten(session.title, 42);
+    }
+    if (isHermesCronSession(session)) {
+        return hermesFallbackSessionLabel(projectRoot, session.id);
+    }
+    const prompt = latestHermesSessionUserText(session, 160);
+    if (prompt) {
+        return shorten(prompt, 42);
+    }
+    const model = session.model ? session.model.replace(/[-_]+/g, " ") : "";
+    return model ? `Hermes ${shorten(model, 24)}` : `Hermes ${session.id.slice(0, 8)}`;
+}
+function sessionSourceKind(session) {
+    if (isHermesCronSession(session)) {
+        return "hermes:cron";
+    }
+    const source = session.source && session.source.trim() ? session.source.trim() : "local";
+    return session.model ? `hermes:${source}:${session.model}` : `hermes:${source}`;
+}
+function sessionRole(session) {
+    return isHermesCronSession(session) ? "temporary" : "hermes";
+}
+function sessionStatusText(session, isOngoing) {
+    if (isOngoing) {
+        return "active";
+    }
+    if (isHermesCronSession(session)) {
+        return "temporary";
+    }
+    return session.endReason ?? (session.endedAt ? "ended" : "open");
+}
+function isCliLikeHermesSource(session) {
+    const source = (session.source ?? "").toLowerCase();
+    return source === "" || source === "cli" || source === "local" || source === "unknown";
+}
+function isHermesCompressionContinuation(session) {
+    return Boolean(session.parentSessionId
+        && session.parentEndReason === "compression"
+        && session.parentEndedAt !== null
+        && session.startedAt >= session.parentEndedAt);
+}
+function hermesHookRecordTimestampMs(record, fallback) {
+    const value = record.timestamp;
+    if (typeof value === "string") {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function hermesHookString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function hermesHookPayloadString(record, key) {
+    const value = record.payload[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function hermesHookPayloadNumber(record, key) {
+    const value = record.payload[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function hermesHookEventTurnId(record) {
+    return hermesHookPayloadString(record, "turn_id")
+        ?? hermesHookPayloadString(record, "parent_turn_id");
+}
+function hermesHookEventItemId(record) {
+    return hermesHookPayloadString(record, "tool_call_id")
+        ?? hermesHookPayloadString(record, "child_subagent_id")
+        ?? hermesHookPayloadString(record, "child_session_id")
+        ?? hermesHookPayloadString(record, "task_id");
+}
+function limitHermesHookValue(value, depth = 0) {
+    if (depth > 5) {
+        return typeof value === "string" ? shorten(value, HERMES_HOOK_TEXT_LIMIT) : String(value);
+    }
+    if (typeof value === "string") {
+        return value.length <= HERMES_HOOK_TEXT_LIMIT
+            ? value
+            : `${value.slice(0, HERMES_HOOK_TEXT_LIMIT)}...[truncated]`;
+    }
+    if (value === null || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 40).map((entry) => limitHermesHookValue(entry, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 60)
+            .map(([key, entry]) => [key, limitHermesHookValue(entry, depth + 1)]));
+    }
+    return undefined;
+}
+async function readHermesHookFileTail(path, size) {
+    const hostPath = hostFilesystemPath(path);
+    if (size <= HERMES_HOOK_FILE_BYTE_LIMIT) {
+        return (0, promises_1.readFile)(hostPath, "utf8").catch(() => "");
+    }
+    const handle = await (0, promises_1.open)(hostPath, "r").catch(() => null);
+    if (!handle) {
+        return "";
+    }
+    try {
+        const length = HERMES_HOOK_FILE_BYTE_LIMIT;
+        const position = Math.max(0, size - length);
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, length, position);
+        const text = buffer.subarray(0, bytesRead).toString("utf8");
+        const firstNewline = text.indexOf("\n");
+        return firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+function normalizeHermesHookRecord(raw, fallback) {
+    const payload = raw.payload && typeof raw.payload === "object" && !Array.isArray(raw.payload)
+        ? limitHermesHookValue(raw.payload)
+        : {};
+    const sessionId = hermesHookString(raw, "session_id")
+        ?? hermesHookString(payload, "session_id")
+        ?? hermesHookString(payload, "parent_session_id")
+        ?? hermesHookString(payload, "child_session_id")
+        ?? fallback.sessionId;
+    return {
+        sessionId,
+        eventName: hermesHookString(raw, "hook_event_name") ?? "unknown",
+        timestampMs: hermesHookRecordTimestampMs(raw, fallback.updatedAtMs),
+        cwd: normalizeFilesystemPath(hermesHookString(raw, "cwd")),
+        processCwd: normalizeFilesystemPath(hermesHookString(raw, "process_cwd")),
+        payload,
+        raw: {}
+    };
+}
+async function loadHermesHookSessions(limit) {
+    const files = [];
+    for (const hooksDir of hermesHookDirectories()) {
+        const entries = await (0, promises_1.readdir)(hostFilesystemPath(hooksDir), { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+                continue;
+            }
+            const filePath = (0, node_path_1.join)(hooksDir, entry.name);
+            const fileStats = await (0, promises_1.stat)(hostFilesystemPath(filePath)).catch(() => null);
+            if (!fileStats?.isFile()) {
+                continue;
+            }
+            files.push({
+                sessionId: entry.name.replace(/\.jsonl$/i, ""),
+                path: filePath,
+                updatedAtMs: fileStats.mtimeMs,
+                size: fileStats.size
+            });
+        }
+    }
+    const groups = new Map();
+    for (const file of files
+        .sort((left, right) => right.updatedAtMs - left.updatedAtMs)
+        .slice(0, Math.max(limit, HERMES_SESSION_SCAN_LIMIT))) {
+        const raw = await readHermesHookFileTail(file.path, file.size);
+        const records = raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .slice(-HERMES_HOOK_RECORD_LIMIT)
+            .map((line) => {
+            if (Buffer.byteLength(line, "utf8") > HERMES_HOOK_LINE_BYTE_LIMIT) {
+                return null;
+            }
+            try {
+                return normalizeHermesHookRecord(JSON.parse(line), file);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((record) => record !== null)
+            .sort((left, right) => left.timestampMs - right.timestampMs);
+        if (records.length > 0) {
+            const sessionId = records[records.length - 1].sessionId;
+            const existing = groups.get(sessionId) ?? [];
+            groups.set(sessionId, [...existing, ...records].sort((left, right) => left.timestampMs - right.timestampMs));
+        }
+    }
+    return groups;
+}
+function collectHermesHookPathCandidates(records) {
+    const paths = new Set();
+    for (const record of records) {
+        for (const candidate of hermesHookPayloadPathCandidates(record)) {
+            paths.add(candidate);
+        }
+        if (record.cwd) {
+            paths.add(record.cwd);
+        }
+        if (record.processCwd) {
+            paths.add(record.processCwd);
+        }
+    }
+    return [...paths].slice(0, HERMES_HOOK_PATH_LIMIT);
+}
+function hermesHookPayloadPathCandidates(record) {
+    const paths = new Set();
+    const text = JSON.stringify(record.payload).slice(0, HERMES_HOOK_TEXT_LIMIT * 4);
+    for (const candidate of extractAbsolutePathCandidates(text)) {
+        const normalized = normalizeCandidatePath(candidate, record.cwd ?? record.processCwd ?? "/");
+        if (normalized) {
+            paths.add(normalized);
+        }
+        if (paths.size >= HERMES_HOOK_PATH_LIMIT) {
+            break;
+        }
+    }
+    return [...paths];
+}
+function recentHermesHookRecordsForProjectRelation(records) {
+    return records.slice(-HERMES_PROJECT_RELATION_ACTION_WINDOW);
+}
+async function currentProjectRootForHermesHookSession(records) {
+    const recentRecords = recentHermesHookRecordsForProjectRelation(records);
+    for (const record of [...recentRecords].reverse()) {
+        const candidates = hermesHookPayloadPathCandidates(record);
+        for (const candidate of candidates) {
+            const root = await resolveProjectRootForPath(candidate);
+            if (root) {
+                return root;
+            }
+        }
+    }
+    for (const record of [...recentRecords].reverse()) {
+        const candidates = [record.cwd, record.processCwd].filter((entry) => Boolean(entry));
+        for (const candidate of candidates) {
+            const root = await resolveProjectRootForPath(candidate);
+            if (root) {
+                return root;
+            }
+        }
+    }
+    return null;
+}
+function hermesHookNestedString(record, path) {
+    let value = record.payload;
+    for (const key of path) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return null;
+        }
+        value = value[key];
+    }
+    return typeof value === "string" && value.trim() ? shorten(value, 240) : null;
+}
+function hermesHookText(record, keys) {
+    for (const key of keys) {
+        const value = record.payload[key];
+        if (typeof value === "string" && value.trim()) {
+            return shorten(value, 240);
+        }
+    }
+    if (keys.includes("user_message")) {
+        return hermesHookNestedString(record, ["event", "text"])
+            ?? hermesHookNestedString(record, ["event", "message"]);
+    }
+    return null;
+}
+function hermesHookToolName(record) {
+    const value = record.payload.tool_name;
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    if (record.eventName === "transform_terminal_output") {
+        return "terminal";
+    }
+    return "tool";
+}
+function hermesHookPlatform(record) {
+    return hermesHookPayloadString(record, "platform");
+}
+function isNonSessionHermesHookId(sessionId) {
+    return sessionId === "default"
+        || sessionId.startsWith("process-")
+        || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+}
+function isDurableHermesHookSessionId(sessionId) {
+    return /^\d{8}_\d{6}_[0-9a-f]+$/i.test(sessionId)
+        || isHermesCronSessionId(sessionId);
+}
+function hermesHookSourceKind(sessionId) {
+    return isHermesCronSessionId(sessionId) ? "hermes:cron" : "hermes:hook";
+}
+function hermesHookRole(sessionId) {
+    return isHermesCronSessionId(sessionId) ? "temporary" : "hermes";
+}
+function hermesHookStatusText(sessionId, isOngoing) {
+    if (isOngoing) {
+        return "active";
+    }
+    return isHermesCronSessionId(sessionId) ? "temporary" : "hook";
+}
+function canonicalHermesSessionIdForHookRecords(records, sessions) {
+    const sessionById = new Map(sessions.map((session) => [session.id, session]));
+    for (const record of [...records].reverse()) {
+        if (sessionById.has(record.sessionId)) {
+            return record.sessionId;
+        }
+        for (const key of ["session_id", "parent_session_id", "child_session_id", "conversation_id"]) {
+            const candidate = hermesHookPayloadString(record, key);
+            if (candidate && sessionById.has(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    const latest = records[records.length - 1];
+    if (!latest || !isNonSessionHermesHookId(latest.sessionId)) {
+        return null;
+    }
+    const latestSeconds = latest.timestampMs / 1000;
+    const platform = hermesHookPlatform(latest);
+    const candidates = sessions
+        .filter((session) => {
+        const started = Number(session.startedAt);
+        const ended = session.endedAt === null ? Number.POSITIVE_INFINITY : Number(session.endedAt);
+        return Number.isFinite(started)
+            && latestSeconds >= started - 60
+            && latestSeconds <= ended + 10 * 60;
+    })
+        .sort((left, right) => {
+        const leftPlatformScore = platform && left.source === platform ? 1 : 0;
+        const rightPlatformScore = platform && right.source === platform ? 1 : 0;
+        if (rightPlatformScore !== leftPlatformScore) {
+            return rightPlatformScore - leftPlatformScore;
+        }
+        const leftDistance = Math.min(Math.abs(left.lastActive - latestSeconds), Math.abs(left.startedAt - latestSeconds), left.endedAt === null ? Number.POSITIVE_INFINITY : Math.abs(left.endedAt - latestSeconds));
+        const rightDistance = Math.min(Math.abs(right.lastActive - latestSeconds), Math.abs(right.startedAt - latestSeconds), right.endedAt === null ? Number.POSITIVE_INFINITY : Math.abs(right.endedAt - latestSeconds));
+        if (leftDistance !== rightDistance) {
+            return leftDistance - rightDistance;
+        }
+        return right.lastActive - left.lastActive;
+    });
+    return candidates[0]?.id ?? null;
+}
+function hermesHookToolArgs(record) {
+    const value = record.payload.args;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (record.eventName === "transform_terminal_output" && typeof record.payload.command === "string") {
+        return { command: record.payload.command };
+    }
+    return {};
+}
+function hermesHookIsToolActivity(eventName) {
+    return eventName === "pre_tool_call"
+        || eventName === "post_tool_call"
+        || eventName === "transform_tool_result"
+        || eventName === "transform_terminal_output";
+}
+function hermesHookIsToolCompletion(eventName) {
+    return eventName === "post_tool_call"
+        || eventName === "transform_tool_result"
+        || eventName === "transform_terminal_output";
+}
+function hermesHookResponseText(record) {
+    return hermesHookText(record, ["assistant_response", "response_text"]);
+}
+function hermesHookTerminalOutput(record) {
+    return hermesHookText(record, ["output", "result"]);
+}
+function hermesHookApiDetail(record) {
+    const provider = typeof record.payload.provider === "string" ? record.payload.provider : "";
+    const model = typeof record.payload.model === "string" ? record.payload.model : "";
+    const finishReason = typeof record.payload.finish_reason === "string" ? record.payload.finish_reason : "";
+    const modelLabel = model.trim() || provider.trim();
+    if (record.eventName === "pre_api_request") {
+        return modelLabel ? `Thinking with ${modelLabel}` : "Thinking with model";
+    }
+    if (/tool/i.test(finishReason)) {
+        return modelLabel ? `Using tools after ${modelLabel}` : "Using tools";
+    }
+    if (/stop|complete|success/i.test(finishReason)) {
+        return modelLabel ? `Answered with ${modelLabel}` : "Answered";
+    }
+    return modelLabel ? `Model request ${modelLabel}` : "Model request";
+}
+function hermesHookResultLooksFailed(record) {
+    if (typeof record.payload.returncode === "number"
+        && record.payload.returncode !== 0) {
+        return true;
+    }
+    if (typeof record.payload.status === "string"
+        && /fail|error/i.test(record.payload.status)) {
+        return true;
+    }
+    const result = parseMaybeJson(record.payload.result ?? record.payload.output);
+    if (result && typeof result === "object") {
+        const object = result;
+        if (typeof object.error === "string" && object.error.trim()) {
+            return true;
+        }
+        if (typeof object.exit_code === "number" && object.exit_code !== 0) {
+            return true;
+        }
+        if (typeof object.returncode === "number" && object.returncode !== 0) {
+            return true;
+        }
+        if (typeof object.status === "string" && /fail|error/i.test(object.status)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hermesHookToolActivityEvent(input) {
+    const toolName = hermesHookToolName(input.record);
+    const args = hermesHookToolArgs(input.record);
+    const kind = toolKind(toolName);
+    const title = input.failed ? `${toolName} failed` : toolTitle(toolName, args);
+    return {
+        type: kind.eventType,
+        action: kind.eventKind === "command" ? "ran"
+            : kind.eventKind === "fileChange" ? "edited"
+                : "updated",
+        path: toolPath(input.projectRoot, input.record.cwd, args) ?? input.paths[0] ?? input.projectRoot,
+        title,
+        isImage: false
+    };
+}
+function hermesHookSubagentStatus(record) {
+    const value = record.payload.child_status;
+    return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : null;
+}
+function hermesHookSubagentRole(record) {
+    return hermesHookText(record, ["child_role"]);
+}
+function hermesHookSubagentGoal(record) {
+    return hermesHookText(record, ["child_goal"]);
+}
+function hermesHookSubagentTitle(record) {
+    const role = hermesHookSubagentRole(record);
+    return role ? `Subagent ${role}` : "Subagent";
+}
+function hermesHookToolSummary(record) {
+    const toolName = hermesHookToolName(record);
+    const args = hermesHookToolArgs(record);
+    const failed = hermesHookIsToolCompletion(record.eventName) && hermesHookResultLooksFailed(record);
+    const kind = toolKind(toolName);
+    return {
+        toolName,
+        args,
+        failed,
+        kind,
+        title: failed ? `${toolName} failed` : toolTitle(toolName, args),
+        latestMessage: hermesHookResponseText(record) ?? hermesHookTerminalOutput(record)
+    };
+}
+function hermesHookMeaningfulText(record) {
+    const assistantText = hermesHookResponseText(record);
+    if (assistantText) {
+        return assistantText;
+    }
+    const childSummary = hermesHookText(record, ["child_summary"]);
+    if (childSummary) {
+        return childSummary;
+    }
+    const terminalOutput = hermesHookTerminalOutput(record);
+    if (terminalOutput) {
+        return terminalOutput;
+    }
+    if (hermesHookIsToolActivity(record.eventName)) {
+        return hermesHookToolSummary(record).title;
+    }
+    return null;
+}
+function hermesHookDisplayUserText(record) {
+    const userText = hermesHookText(record, ["user_message"]);
+    if (!userText) {
+        return null;
+    }
+    if (/^\[IMPORTANT:/i.test(userText) && hermesSkillNameFromText(userText)) {
+        return null;
+    }
+    const title = hermesTitleFromText(userText);
+    if (title && hermesTitleLooksGenericPrompt(title)) {
+        return null;
+    }
+    return userText;
+}
+function hermesHookConversationText(record) {
+    return hermesHookResponseText(record)
+        ?? hermesHookText(record, ["child_summary"]);
+}
+function latestHermesHookMeaningfulText(records) {
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+        const text = hermesHookMeaningfulText(records[index]);
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function latestHermesHookConversationText(records) {
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+        const text = hermesHookConversationText(records[index]);
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function summarizeHermesHookSession(input) {
+    const latest = input.records[input.records.length - 1];
+    const ageMs = input.now - latest.timestampMs;
+    const recentOpen = ageMs <= HERMES_RECENT_OPEN_WINDOW_MS;
+    const recentDone = ageMs <= HERMES_RECENT_DONE_WINDOW_MS;
+    const isFinalized = latest.eventName === "on_session_finalize";
+    const assistantText = hermesHookResponseText(latest);
+    const userText = hermesHookText(latest, ["user_message"]);
+    const conversationText = latestHermesHookConversationText(input.records);
+    if (hermesHookIsToolActivity(latest.eventName)) {
+        const toolSummary = hermesHookToolSummary(latest);
+        return {
+            state: toolSummary.failed ? "blocked" : toolSummary.kind.state,
+            isOngoing: recentOpen && !isFinalized,
+            detail: toolSummary.title,
+            paths: input.paths,
+            activityEvent: hermesHookToolActivityEvent({
+                record: latest,
+                projectRoot: input.projectRoot,
+                paths: input.paths,
+                failed: toolSummary.failed
+            }),
+            latestMessage: conversationText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: toolSummary.failed || isFinalized ? latest.timestampMs : null
+        };
+    }
+    if (latest.eventName === "post_llm_call" || latest.eventName === "transform_llm_output") {
+        return {
+            state: recentDone ? "done" : "idle",
+            isOngoing: recentDone && !isFinalized,
+            detail: assistantText ?? "Hermes reply",
+            paths: input.paths,
+            activityEvent: assistantText
+                ? {
+                    type: "agentMessage",
+                    action: "said",
+                    path: input.paths[0] ?? input.projectRoot,
+                    title: assistantText,
+                    isImage: false
+                }
+                : null,
+            latestMessage: conversationText ?? assistantText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: recentDone || isFinalized ? latest.timestampMs : null
+        };
+    }
+    if (latest.eventName === "pre_api_request" || latest.eventName === "post_api_request") {
+        const detail = hermesHookApiDetail(latest);
+        return {
+            state: latest.eventName === "pre_api_request" ? "thinking" : (recentOpen ? "thinking" : "idle"),
+            isOngoing: recentOpen && !isFinalized,
+            detail,
+            paths: input.paths,
+            activityEvent: {
+                type: "reasoning",
+                action: "updated",
+                path: input.paths[0] ?? input.projectRoot,
+                title: detail,
+                isImage: false
+            },
+            latestMessage: conversationText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: recentOpen && !isFinalized ? null : latest.timestampMs
+        };
+    }
+    if (latest.eventName === "pre_verify") {
+        const changedPaths = hermesHookChangedPaths(latest, input.projectRoot);
+        const detail = hermesHookPreVerifyDetail(latest, input.projectRoot);
+        return {
+            state: "validating",
+            isOngoing: recentOpen && !isFinalized,
+            detail,
+            paths: [...new Set([...changedPaths, ...input.paths])].slice(0, HERMES_HOOK_PATH_LIMIT),
+            activityEvent: {
+                type: "other",
+                action: "updated",
+                path: changedPaths[0] ?? input.paths[0] ?? input.projectRoot,
+                title: detail,
+                isImage: false
+            },
+            latestMessage: conversationText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: recentOpen && !isFinalized ? null : latest.timestampMs
+        };
+    }
+    if (latest.eventName === "subagent_start") {
+        const title = hermesHookSubagentTitle(latest);
+        const childGoal = hermesHookSubagentGoal(latest);
+        return {
+            state: "delegating",
+            isOngoing: recentOpen && !isFinalized,
+            detail: childGoal ?? `${title} starting`,
+            paths: input.paths,
+            activityEvent: {
+                type: "collabAgentToolCall",
+                action: "updated",
+                path: input.paths[0] ?? input.projectRoot,
+                title: childGoal ?? title,
+                isImage: false
+            },
+            latestMessage: conversationText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: recentOpen && !isFinalized ? null : latest.timestampMs
+        };
+    }
+    if (latest.eventName === "subagent_stop") {
+        const childRole = hermesHookSubagentRole(latest);
+        const childSummary = hermesHookText(latest, ["child_summary"]);
+        const status = hermesHookSubagentStatus(latest);
+        const failed = status ? /fail|error|interrupt/.test(status) : false;
+        const title = childRole ? `Subagent ${childRole}` : "Subagent";
+        return {
+            state: failed ? "blocked" : "delegating",
+            isOngoing: recentOpen && !isFinalized,
+            detail: childSummary ?? (status ? `${title} ${status}` : `${title} stopped`),
+            paths: input.paths,
+            activityEvent: {
+                type: "collabAgentToolCall",
+                action: "updated",
+                path: input.paths[0] ?? input.projectRoot,
+                title: childSummary ?? title,
+                isImage: false
+            },
+            latestMessage: conversationText ?? childSummary,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: failed || !recentOpen ? latest.timestampMs : null
+        };
+    }
+    if (latest.eventName === "on_session_end" || latest.eventName === "on_session_finalize") {
+        const meaningfulText = conversationText ?? latestHermesHookMeaningfulText(input.records);
+        return {
+            state: "done",
+            isOngoing: false,
+            detail: meaningfulText ?? (latest.eventName === "on_session_end" ? "Hermes session ended" : "Hermes session finalized"),
+            paths: input.paths,
+            activityEvent: null,
+            latestMessage: meaningfulText ?? assistantText,
+            updatedAtMs: latest.timestampMs,
+            stoppedAtMs: latest.timestampMs
+        };
+    }
+    return {
+        state: "planning",
+        isOngoing: recentOpen,
+        detail: userText ?? "Hermes session activity",
+        paths: input.paths,
+        activityEvent: {
+            type: latest.eventName === "pre_gateway_dispatch" ? "userMessage" : "plan",
+            action: "updated",
+            path: input.paths[0] ?? input.projectRoot,
+            title: userText ?? latest.eventName,
+            isImage: false
+        },
+        latestMessage: conversationText ?? assistantText,
+        updatedAtMs: latest.timestampMs,
+        stoppedAtMs: recentOpen ? null : latest.timestampMs
+    };
+}
+function buildHermesHookEvents(input) {
+    const records = input.records.slice(-20);
+    const startIndex = input.records.length - records.length;
+    return records.map((record, index) => {
+        const toolName = hermesHookToolName(record);
+        const kind = hermesHookIsToolActivity(record.eventName) ? toolKind(toolName) : null;
+        const args = kind ? hermesHookToolArgs(record) : {};
+        const toolEventTitle = kind ? toolTitle(toolName, args) : "";
+        const toolEventPath = kind
+            ? toolPath(input.projectRoot, record.cwd, args) ?? input.projectRoot
+            : input.projectRoot;
+        const command = kind?.eventKind === "command"
+            ? (typeof args.command === "string" && args.command.trim()
+                ? shorten(args.command, 240)
+                : toolName === "process" ? toolEventTitle : undefined)
+            : undefined;
+        const assistantText = hermesHookResponseText(record) ?? hermesHookTerminalOutput(record);
+        const userText = hermesHookText(record, ["user_message"]);
+        const lifecycleText = record.eventName === "on_session_end" || record.eventName === "on_session_finalize"
+            ? latestHermesHookMeaningfulText(input.records.slice(0, startIndex + index + 1))
+            : null;
+        const changedPaths = record.eventName === "pre_verify"
+            ? hermesHookChangedPaths(record, input.projectRoot)
+            : [];
+        const preVerifyDetail = record.eventName === "pre_verify"
+            ? hermesHookPreVerifyDetail(record, input.projectRoot)
+            : null;
+        const subagentLifecycle = record.eventName === "subagent_start" || record.eventName === "subagent_stop";
+        const subagentTitle = subagentLifecycle ? hermesHookSubagentTitle(record) : null;
+        const subagentDetail = record.eventName === "subagent_start"
+            ? hermesHookSubagentGoal(record) ?? `${subagentTitle ?? "Subagent"} starting`
+            : record.eventName === "subagent_stop"
+                ? hermesHookText(record, ["child_summary"])
+                    ?? (hermesHookSubagentStatus(record)
+                        ? `${subagentTitle ?? "Subagent"} ${hermesHookSubagentStatus(record)}`
+                        : `${subagentTitle ?? "Subagent"} stopped`)
+                : null;
+        const eventPath = changedPaths[0] ?? toolEventPath;
+        const method = kind?.eventType === "plan"
+            ? "turn/plan/updated"
+            : kind?.eventKind === "command"
+                ? record.eventName === "pre_tool_call" ? "item/started" : "item/commandExecution/outputDelta"
+                : kind?.eventKind === "fileChange"
+                    ? record.eventName === "pre_tool_call" ? "item/started" : "item/fileChange/outputDelta"
+                    : kind?.eventKind === "tool"
+                        ? toolName.startsWith("mcp_") && record.eventName !== "pre_tool_call" ? "item/mcpToolCall/progress" : "item/tool/call"
+                        : record.eventName === "pre_llm_call" || record.eventName === "pre_gateway_dispatch"
+                            ? "hermes/userMessage"
+                            : record.eventName === "post_llm_call" || record.eventName === "transform_llm_output"
+                                ? "hermes/agentMessage"
+                                : record.eventName === "pre_verify"
+                                    ? "hermes/preVerify"
+                                    : record.eventName === "subagent_start"
+                                        ? "hermes/subagentStart"
+                                        : record.eventName === "subagent_stop"
+                                            ? "hermes/subagentStop"
+                                            : `hermes/${record.eventName}`;
+        const eventKind = kind?.eventKind
+            ?? (subagentLifecycle ? "subagent"
+                : record.eventName === "pre_api_request" || record.eventName === "post_api_request" || record.eventName === "pre_verify" ? "status" : "message");
+        const apiDetail = record.eventName === "pre_api_request" || record.eventName === "post_api_request"
+            ? hermesHookApiDetail(record)
+            : null;
+        const detail = kind ? toolEventTitle
+            : preVerifyDetail ?? subagentDetail ?? apiDetail ?? lifecycleText ?? assistantText ?? userText ?? record.eventName;
+        const action = kind?.eventKind === "command" ? "ran"
+            : kind?.eventKind === "fileChange" ? "edited"
+                : kind?.eventType === "plan" ? "updated"
+                    : eventKind === "message" ? "said"
+                        : "updated";
+        return {
+            id: `${input.projectRoot}::hermes-hook::${record.sessionId}::${record.timestampMs}::${index}`,
+            source: "hermes",
+            confidence: "typed",
+            threadId: input.threadId ?? record.sessionId,
+            createdAt: new Date(record.timestampMs).toISOString(),
+            method,
+            turnId: hermesHookEventTurnId(record) ?? undefined,
+            itemId: hermesHookEventItemId(record) ?? undefined,
+            requestId: hermesHookPayloadString(record, "api_request_id") ?? undefined,
+            itemType: kind?.eventType === "mcpToolCall" ? "mcpToolCall"
+                : kind?.eventType === "dynamicToolCall" ? "dynamicToolCall"
+                    : subagentLifecycle ? "collabAgentToolCall"
+                        : eventKind === "message" && (record.eventName === "pre_llm_call" || record.eventName === "pre_gateway_dispatch") ? "userMessage"
+                            : eventKind === "message" ? "agentMessage"
+                                : undefined,
+            kind: eventKind,
+            phase: kind?.eventType === "plan"
+                ? "updated"
+                : hermesHookIsToolCompletion(record.eventName)
+                    ? hermesHookResultLooksFailed(record) ? "failed" : "completed"
+                    : record.eventName === "pre_tool_call" || record.eventName === "pre_verify" || record.eventName === "subagent_start" ? "started" : "updated",
+            title: kind ? toolEventTitle : preVerifyDetail ?? subagentTitle ?? record.eventName,
+            detail,
+            path: eventPath,
+            action,
+            command,
+            cwd: record.cwd ?? undefined,
+            isImage: false
+        };
+    });
+}
+function summarizeHermesSession(input) {
+    const { session, projectRoot, cwd, activeProcess, paths, now } = input;
+    const latest = [...session.messages].reverse().find((message) => message.role) ?? null;
+    const latestCall = latestMessageToolCall(latest);
+    const latestMessage = latestAssistantText(session.messages);
+    const latestUser = latestHermesSessionUserText(session);
+    const promptDetail = latestUser ?? (isHermesCronSession(session) ? "Scheduled cron job" : "Hermes prompt");
+    const lastActiveMs = Math.max(session.lastActive * 1000, session.startedAt * 1000);
+    const ageMs = now - lastActiveMs;
+    const isEnded = session.endedAt !== null;
+    const active = Boolean(activeProcess);
+    const freshOpen = !isEnded && ageMs <= HERMES_RECENT_OPEN_WINDOW_MS;
+    const hasUnfinishedTurn = latest?.role === "user"
+        || latest?.role === "tool"
+        || (latest?.role === "assistant" && latestCall !== null);
+    const isOngoing = !isEnded && (freshOpen || (hasUnfinishedTurn && active));
+    if (latest?.role === "tool" && messageLooksFailed(latest)) {
+        const toolName = latest.toolName ?? "tool";
+        return {
+            state: "blocked",
+            isOngoing,
+            detail: `${toolName} failed`,
+            paths,
+            activityEvent: {
+                type: toolKind(toolName).eventType,
+                action: "updated",
+                path: paths[0] ?? projectRoot,
+                title: `${toolName} failed`,
+                isImage: false
+            },
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: isOngoing ? null : lastActiveMs
+        };
+    }
+    if (latestCall && isOngoing) {
+        const kind = toolKind(latestCall.name);
+        return {
+            state: kind.state,
+            isOngoing: true,
+            detail: toolTitle(latestCall.name, latestCall.args),
+            paths,
+            activityEvent: toolActivityEvent(projectRoot, cwd, latestCall),
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: null
+        };
+    }
+    if (latest?.role === "tool" && isOngoing) {
+        const toolName = latest.toolName ?? "tool";
+        return {
+            state: "thinking",
+            isOngoing: true,
+            detail: `${toolName} result`,
+            paths,
+            activityEvent: {
+                type: toolKind(toolName).eventType,
+                action: "updated",
+                path: paths[0] ?? projectRoot,
+                title: `${toolName} result`,
+                isImage: false
+            },
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: null
+        };
+    }
+    if (latest?.role === "user" && isOngoing) {
+        return {
+            state: "planning",
+            isOngoing: true,
+            detail: promptDetail,
+            paths,
+            activityEvent: {
+                type: "userMessage",
+                action: "said",
+                path: paths[0] ?? projectRoot,
+                title: promptDetail,
+                isImage: false
+            },
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: null
+        };
+    }
+    if (active && session.messages.length === 0) {
+        return {
+            state: "thinking",
+            isOngoing: true,
+            detail: latestMessage ?? latestUser ?? "Hermes is active",
+            paths,
+            activityEvent: latestMessage
+                ? {
+                    type: "agentMessage",
+                    action: "said",
+                    path: paths[0] ?? projectRoot,
+                    title: latestMessage,
+                    isImage: false
+                }
+                : null,
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: null
+        };
+    }
+    if (freshOpen) {
+        return {
+            state: "waiting",
+            isOngoing: true,
+            detail: latestMessage ?? latestUser ?? (isHermesCronSession(session) ? "Scheduled cron job open" : "Hermes session open"),
+            paths,
+            activityEvent: latestMessage
+                ? {
+                    type: "agentMessage",
+                    action: "said",
+                    path: paths[0] ?? projectRoot,
+                    title: latestMessage,
+                    isImage: false
+                }
+                : null,
+            latestMessage,
+            updatedAtMs: lastActiveMs,
+            stoppedAtMs: null
+        };
+    }
+    const recentlyDone = ageMs <= HERMES_RECENT_DONE_WINDOW_MS;
+    return {
+        state: recentlyDone ? "done" : "idle",
+        isOngoing: false,
+        detail: latestMessage ?? latestUser ?? (isEnded ? "Finished" : isHermesCronSession(session) ? "Scheduled cron job" : "Hermes session"),
+        paths,
+        activityEvent: latestMessage
+            ? {
+                type: "agentMessage",
+                action: "said",
+                path: paths[0] ?? projectRoot,
+                title: latestMessage,
+                isImage: false
+            }
+            : null,
+        latestMessage,
+        updatedAtMs: lastActiveMs,
+        stoppedAtMs: isEnded || recentlyDone ? lastActiveMs : null
+    };
+}
+function buildHermesMessageEvents(input) {
+    const events = [];
+    for (const message of input.session.messages) {
+        const createdAt = new Date((message.timestamp || input.session.lastActive) * 1000).toISOString();
+        const baseId = `${input.projectRoot}::hermes::${input.session.id}::${message.id}`;
+        if (message.role === "user") {
+            const detail = textFromContent(message.content);
+            if (!detail) {
+                continue;
+            }
+            events.push({
+                id: `${baseId}::user`,
+                source: "hermes",
+                confidence: "inferred",
+                threadId: input.session.id,
+                createdAt,
+                method: "hermes/userMessage",
+                kind: "message",
+                phase: "updated",
+                title: "Hermes prompt",
+                detail: shorten(detail, 240),
+                path: input.projectRoot,
+                action: "said",
+                isImage: false
+            });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const calls = parseToolCalls(message.toolCalls);
+            calls.forEach((call, index) => {
+                const kind = toolKind(call.name);
+                const path = toolPath(input.projectRoot, input.cwd, call.args);
+                events.push({
+                    id: `${baseId}::tool-${index}`,
+                    source: "hermes",
+                    confidence: "inferred",
+                    threadId: input.session.id,
+                    createdAt,
+                    method: "item/started",
+                    kind: kind.eventKind,
+                    phase: "started",
+                    title: call.name,
+                    detail: toolTitle(call.name, call.args),
+                    path,
+                    command: typeof call.args.command === "string" ? call.args.command : undefined,
+                    action: kind.eventKind === "command" ? "ran" : "updated",
+                    isImage: false
+                });
+            });
+            const detail = textFromContent(message.content);
+            if (detail) {
+                events.push({
+                    id: `${baseId}::assistant`,
+                    source: "hermes",
+                    confidence: "inferred",
+                    threadId: input.session.id,
+                    createdAt,
+                    method: "hermes/agentMessage",
+                    kind: "message",
+                    phase: "updated",
+                    title: "Hermes reply",
+                    detail: shorten(detail, 240),
+                    path: input.projectRoot,
+                    action: "said",
+                    isImage: false
+                });
+            }
+            continue;
+        }
+        if (message.role === "tool" && message.toolName) {
+            const kind = toolKind(message.toolName);
+            const failed = messageLooksFailed(message);
+            const detail = textFromContent(message.content);
+            events.push({
+                id: `${baseId}::tool-result`,
+                source: "hermes",
+                confidence: "inferred",
+                threadId: input.session.id,
+                createdAt,
+                method: "item/completed",
+                kind: kind.eventKind,
+                phase: failed ? "failed" : "completed",
+                title: message.toolName,
+                detail: shorten(detail || message.toolName, 240),
+                path: input.projectRoot,
+                action: kind.eventKind === "command" ? "ran" : "updated",
+                isImage: false
+            });
+        }
+    }
+    return events;
+}
+async function gitInfoForProject(projectRoot) {
+    void projectRoot;
+    return {
+        sha: null,
+        branch: null,
+        originUrl: null
+    };
+}
+async function allHermesHomes(processes) {
+    const homes = new Set(await hermesHomeCandidatesFromDisk());
+    for (const processInfo of processes) {
+        if (processInfo.hermesHome) {
+            homes.add(processInfo.hermesHome);
+        }
+    }
+    return [...homes].filter(Boolean);
+}
+function latestActiveSessionForHome(sessions, home) {
+    if (!home) {
+        return null;
+    }
+    return sessions
+        .filter((session) => session.home === home
+        && !session.endedAt
+        && isCliLikeHermesSource(session))
+        .sort((left, right) => right.lastActive - left.lastActive)[0] ?? null;
+}
+async function loadHermesProjectSnapshotData(projectRoot, limit = hermesLocalSessionLimit()) {
+    const canonicalRoot = (0, project_paths_1.canonicalizeProjectPath)(projectRoot);
+    if (!canonicalRoot) {
+        return { agents: [], events: [], notes: [] };
+    }
+    const notes = [];
+    const processes = await scanHermesProcesses();
+    const projectProcesses = processes.filter((processInfo) => pathWithinProject(canonicalRoot, processInfo.cwd));
+    const scanLimit = hermesScanLimit(limit);
+    const hookSessions = await loadHermesHookSessions(scanLimit);
+    const homes = await allHermesHomes(processes);
+    const sessionGroups = await Promise.all(homes.map((home) => loadHermesSessions(home, scanLimit, notes)));
+    const sessions = sessionGroups.flat().sort((left, right) => right.lastActive - left.lastActive);
+    const activeSessionIds = new Set();
+    for (const processInfo of projectProcesses) {
+        const activeSession = latestActiveSessionForHome(sessions, processInfo.hermesHome);
+        if (activeSession) {
+            activeSessionIds.add(activeSession.id);
+        }
+    }
+    const now = Date.now();
+    const git = await gitInfoForProject(canonicalRoot);
+    const agents = [];
+    const events = [];
+    const includedSessionIds = new Set();
+    const hookRecordsBySessionId = new Map();
+    for (const records of hookSessions.values()) {
+        const currentRoot = await currentProjectRootForHermesHookSession(records);
+        if (!currentRoot || !(0, project_paths_1.sameProjectPath)(currentRoot, canonicalRoot)) {
+            continue;
+        }
+        const canonicalSessionId = canonicalHermesSessionIdForHookRecords(records, sessions);
+        const latest = records[records.length - 1];
+        const hookOnlySessionId = latest && isDurableHermesHookSessionId(latest.sessionId)
+            ? latest.sessionId
+            : null;
+        const visibleSessionId = canonicalSessionId ?? hookOnlySessionId;
+        if (!visibleSessionId) {
+            continue;
+        }
+        const existing = hookRecordsBySessionId.get(visibleSessionId) ?? [];
+        hookRecordsBySessionId.set(visibleSessionId, [...existing, ...records].sort((left, right) => left.timestampMs - right.timestampMs));
+    }
+    for (const session of sessions) {
+        if (includedSessionIds.has(session.id)) {
+            continue;
+        }
+        const activeProcess = projectProcesses.find((processInfo) => processInfo.hermesHome === session.home && activeSessionIds.has(session.id)) ?? null;
+        const sessionCwd = cwdFromSystemPrompt(session.systemPrompt);
+        const fallbackCwd = activeProcess?.cwd ?? sessionCwd;
+        const currentRoot = await currentProjectRootForHermesSession(session, activeProcess);
+        if (!currentRoot || !(0, project_paths_1.sameProjectPath)(currentRoot, canonicalRoot)) {
+            continue;
+        }
+        const candidatePaths = collectSessionPathCandidates(session, fallbackCwd);
+        const projectPaths = candidatePaths.filter((candidate) => pathWithinProject(canonicalRoot, candidate));
+        const cwd = activeProcess?.cwd ?? (pathWithinProject(canonicalRoot, sessionCwd) ? sessionCwd : null) ?? currentRoot;
+        const paths = projectPaths.length > 0 ? projectPaths : [cwd];
+        const summary = summarizeHermesSession({
+            session,
+            projectRoot: canonicalRoot,
+            cwd,
+            activeProcess,
+            paths,
+            now
+        });
+        const hookRecords = hookRecordsBySessionId.get(session.id) ?? [];
+        const hookPaths = collectHermesHookPathCandidates(hookRecords).filter((candidate) => pathWithinProject(canonicalRoot, candidate));
+        const hookSummary = hookRecords.length > 0
+            ? summarizeHermesHookSession({
+                records: hookRecords,
+                projectRoot: canonicalRoot,
+                paths: hookPaths.length > 0 ? hookPaths : paths,
+                now
+            })
+            : null;
+        const visibleSummary = hookSummary && hookSummary.updatedAtMs >= summary.updatedAtMs
+            ? {
+                ...hookSummary,
+                latestMessage: hookSummary.latestMessage ?? summary.latestMessage,
+                paths: [...new Set([...hookSummary.paths, ...summary.paths])].slice(0, HERMES_HOOK_PATH_LIMIT)
+            }
+            : summary;
+        if (visibleSummary.state === "idle" && !visibleSummary.isOngoing) {
+            continue;
+        }
+        const appearance = await (0, appearance_1.ensureAgentAppearance)(canonicalRoot, `hermes:${session.id}`);
+        const isContinuation = isHermesCompressionContinuation(session);
+        agents.push({
+            id: `hermes:${session.id}`,
+            label: sessionLabel(session, canonicalRoot),
+            source: "hermes",
+            sourceKind: sessionSourceKind(session),
+            parentThreadId: !isContinuation && session.parentSessionId ? `hermes:${session.parentSessionId}` : null,
+            depth: !isContinuation && session.parentSessionId ? 1 : 0,
+            isCurrent: visibleSummary.isOngoing,
+            isOngoing: visibleSummary.isOngoing,
+            statusText: sessionStatusText(session, visibleSummary.isOngoing),
+            role: sessionRole(session),
+            nickname: null,
+            isSubagent: Boolean(!isContinuation && session.parentSessionId),
+            state: visibleSummary.state,
+            detail: visibleSummary.detail,
+            cwd,
+            roomId: null,
+            appearance,
+            updatedAt: new Date(visibleSummary.updatedAtMs).toISOString(),
+            stoppedAt: visibleSummary.stoppedAtMs ? new Date(visibleSummary.stoppedAtMs).toISOString() : null,
+            paths: visibleSummary.paths,
+            activityEvent: visibleSummary.activityEvent,
+            latestMessage: visibleSummary.latestMessage,
+            threadId: session.id,
+            taskId: null,
+            resumeCommand: null,
+            url: null,
+            git,
+            provenance: "hermes",
+            confidence: hookSummary ? "typed" : "inferred",
+            needsUser: null,
+            liveSubscription: "readOnly",
+            network: null
+        });
+        includedSessionIds.add(session.id);
+        events.push(...buildHermesMessageEvents({
+            session,
+            projectRoot: canonicalRoot,
+            cwd
+        }));
+        if (hookRecords.length > 0) {
+            events.push(...buildHermesHookEvents({ records: hookRecords, projectRoot: canonicalRoot, threadId: session.id }));
+        }
+    }
+    for (const [sessionId, hookRecords] of hookRecordsBySessionId) {
+        if (includedSessionIds.has(sessionId) || !isDurableHermesHookSessionId(sessionId)) {
+            continue;
+        }
+        const hookPaths = collectHermesHookPathCandidates(hookRecords).filter((candidate) => pathWithinProject(canonicalRoot, candidate));
+        const latest = hookRecords[hookRecords.length - 1];
+        const cwd = pathWithinProject(canonicalRoot, latest?.cwd) ? latest?.cwd ?? canonicalRoot : canonicalRoot;
+        const paths = hookPaths.length > 0 ? hookPaths : [cwd];
+        const summary = summarizeHermesHookSession({
+            records: hookRecords,
+            projectRoot: canonicalRoot,
+            paths,
+            now
+        });
+        if (summary.state === "idle" && !summary.isOngoing) {
+            continue;
+        }
+        const appearance = await (0, appearance_1.ensureAgentAppearance)(canonicalRoot, `hermes:${sessionId}`);
+        agents.push({
+            id: `hermes:${sessionId}`,
+            label: hermesHookSessionLabel(hookRecords, canonicalRoot, summary.latestMessage),
+            source: "hermes",
+            sourceKind: hermesHookSourceKind(sessionId),
+            parentThreadId: null,
+            depth: 0,
+            isCurrent: summary.isOngoing,
+            isOngoing: summary.isOngoing,
+            statusText: hermesHookStatusText(sessionId, summary.isOngoing),
+            role: hermesHookRole(sessionId),
+            nickname: null,
+            isSubagent: false,
+            state: summary.state,
+            detail: summary.detail,
+            cwd,
+            roomId: null,
+            appearance,
+            updatedAt: new Date(summary.updatedAtMs).toISOString(),
+            stoppedAt: summary.stoppedAtMs ? new Date(summary.stoppedAtMs).toISOString() : null,
+            paths: summary.paths,
+            activityEvent: summary.activityEvent,
+            latestMessage: summary.latestMessage,
+            threadId: sessionId,
+            taskId: null,
+            resumeCommand: null,
+            url: null,
+            git,
+            provenance: "hermes",
+            confidence: "typed",
+            needsUser: null,
+            liveSubscription: "readOnly",
+            network: null
+        });
+        includedSessionIds.add(sessionId);
+        events.push(...buildHermesHookEvents({ records: hookRecords, projectRoot: canonicalRoot, threadId: sessionId }));
+    }
+    for (const processInfo of projectProcesses) {
+        const hasIncludedSession = sessions.some((session) => includedSessionIds.has(session.id)
+            && session.home === processInfo.hermesHome
+            && activeSessionIds.has(session.id));
+        if (hasIncludedSession || !processInfo.cwd) {
+            continue;
+        }
+        const appearance = await (0, appearance_1.ensureAgentAppearance)(canonicalRoot, `hermes-process:${processInfo.pid}`);
+        agents.push({
+            id: `hermes-process:${processInfo.pid}`,
+            label: "Hermes CLI",
+            source: "hermes",
+            sourceKind: "hermes:process",
+            parentThreadId: null,
+            depth: 0,
+            isCurrent: true,
+            isOngoing: true,
+            statusText: "active",
+            role: "hermes",
+            nickname: null,
+            isSubagent: false,
+            state: "planning",
+            detail: "Hermes process in workspace",
+            cwd: processInfo.cwd,
+            roomId: null,
+            appearance,
+            updatedAt: new Date(processInfo.updatedAtMs).toISOString(),
+            stoppedAt: null,
+            paths: [processInfo.cwd],
+            activityEvent: null,
+            latestMessage: null,
+            threadId: `process:${processInfo.pid}`,
+            taskId: null,
+            resumeCommand: null,
+            url: null,
+            git,
+            provenance: "hermes",
+            confidence: "inferred",
+            needsUser: null,
+            liveSubscription: "readOnly",
+            network: null
+        });
+    }
+    return {
+        agents: agents
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .slice(0, limit),
+        events: events.sort((left, right) => right.createdAt.localeCompare(left.createdAt)),
+        notes
+    };
+}
+async function discoverHermesProjects(limit = 20) {
+    const projects = new Map();
+    const processes = await scanHermesProcesses();
+    const scanLimit = hermesScanLimit(limit);
+    const hookSessions = await loadHermesHookSessions(scanLimit);
+    const now = Date.now();
+    const notes = [];
+    const upsertProject = async (root, updatedAtSeconds) => {
+        const key = (0, project_paths_1.projectPathIdentityKey)(root);
+        if (!root || !key) {
+            return;
+        }
+        if (HERMES_TRANSIENT_PROJECT_ROOTS.has(root.replace(/\\/g, "/").toLowerCase())) {
+            return;
+        }
+        if (await looksLikeHermesRuntimeProjectRoot(root)) {
+            return;
+        }
+        if (!await pathExists((0, node_path_1.join)(root, ".git"))) {
+            return;
+        }
+        const existing = projects.get(key);
+        if (existing) {
+            existing.updatedAt = Math.max(existing.updatedAt, updatedAtSeconds);
+            existing.count += 1;
+            return;
+        }
+        projects.set(key, {
+            root,
+            label: (0, project_paths_1.projectLabelFromRoot)(root),
+            updatedAt: updatedAtSeconds,
+            count: 1
+        });
+    };
+    for (const processInfo of processes) {
+        if (!processInfo.cwd) {
+            continue;
+        }
+        const root = await resolveProjectRootForPath(processInfo.cwd);
+        await upsertProject(root, Math.floor(processInfo.updatedAtMs / 1000));
+    }
+    for (const records of hookSessions.values()) {
+        const latest = records[records.length - 1];
+        if (!latest || now - latest.timestampMs > HERMES_PROJECT_DISCOVERY_HOOK_WINDOW_MS) {
+            continue;
+        }
+        const summary = summarizeHermesHookSession({
+            records,
+            projectRoot: latest.cwd ?? latest.processCwd ?? "/",
+            paths: collectHermesHookPathCandidates(records),
+            now
+        });
+        if (summary.state === "idle" && !summary.isOngoing) {
+            continue;
+        }
+        const currentRoot = await currentProjectRootForHermesHookSession(records);
+        await upsertProject(currentRoot, Math.floor(latest.timestampMs / 1000));
+    }
+    const homes = await allHermesHomes(processes);
+    const sessionGroups = await Promise.all(homes.map((home) => loadHermesSessions(home, scanLimit, notes)));
+    for (const session of sessionGroups.flat()) {
+        if (session.endedAt !== null) {
+            continue;
+        }
+        const lastActiveMs = Math.max(session.lastActive * 1000, session.startedAt * 1000);
+        if (now - lastActiveMs > HERMES_RECENT_OPEN_WINDOW_MS) {
+            continue;
+        }
+        const root = await currentProjectRootForHermesSession(session, null);
+        await upsertProject(root, Math.floor(lastActiveMs / 1000));
+    }
+    return [...projects.values()]
+        .sort((left, right) => right.updatedAt - left.updatedAt)
+        .slice(0, limit);
+}
+async function loadRoamingHermesSnapshotData(input) {
+    const anchorRoot = (0, project_paths_1.canonicalizeProjectPath)(input.anchorProjectRoot);
+    if (!anchorRoot) {
+        return { agents: [], events: [], notes: [] };
+    }
+    const knownRoots = input.knownProjectRoots
+        .map((root) => (0, project_paths_1.canonicalizeProjectPath)(root))
+        .filter((root) => Boolean(root));
+    const limit = input.limit ?? 4;
+    const hookSessions = await loadHermesHookSessions(hermesScanLimit(limit));
+    const now = Date.now();
+    const gitByRoot = new Map();
+    const gitForRoot = async (root) => {
+        const key = (0, project_paths_1.projectPathIdentityKey)(root) ?? root;
+        const existing = gitByRoot.get(key);
+        if (existing) {
+            return existing;
+        }
+        const git = await gitInfoForProject(root);
+        gitByRoot.set(key, git);
+        return git;
+    };
+    const agents = [];
+    const events = [];
+    for (const [sessionId, records] of hookSessions.entries()) {
+        if (isNonSessionHermesHookId(sessionId)) {
+            continue;
+        }
+        const currentRoot = await currentProjectRootForHermesHookSession(records);
+        const candidatePaths = collectHermesHookPathCandidates(records);
+        const isInsideKnownWorkspace = Boolean(currentRoot
+            && knownRoots.some((root) => (0, project_paths_1.sameProjectPath)(root, currentRoot) || pathWithinProject(root, currentRoot)));
+        if (isInsideKnownWorkspace) {
+            continue;
+        }
+        const sourceRoot = currentRoot ?? anchorRoot;
+        const summary = summarizeHermesHookSession({
+            records,
+            projectRoot: sourceRoot,
+            paths: candidatePaths,
+            now
+        });
+        if (summary.state === "idle" && !summary.isOngoing) {
+            continue;
+        }
+        const latest = records[records.length - 1];
+        const appearance = await (0, appearance_1.ensureAgentAppearance)(sourceRoot, `hermes:${sessionId}`);
+        const statusText = isHermesCronSessionId(sessionId)
+            ? hermesHookStatusText(sessionId, summary.isOngoing)
+            : summary.isOngoing ? "roaming" : summary.state;
+        agents.push({
+            id: `hermes:${sessionId}`,
+            label: hermesHookSessionLabel(records, sourceRoot, summary.latestMessage),
+            source: "hermes",
+            sourceKind: "hermes:roaming",
+            parentThreadId: null,
+            depth: 0,
+            isCurrent: false,
+            isOngoing: summary.isOngoing,
+            statusText,
+            role: hermesHookRole(sessionId),
+            nickname: null,
+            isSubagent: false,
+            state: summary.state,
+            detail: summary.detail,
+            cwd: latest.cwd ?? latest.processCwd ?? null,
+            sourceProjectRoot: sourceRoot,
+            roomId: null,
+            appearance,
+            updatedAt: new Date(summary.updatedAtMs).toISOString(),
+            stoppedAt: summary.stoppedAtMs ? new Date(summary.stoppedAtMs).toISOString() : null,
+            paths: [],
+            activityEvent: summary.activityEvent,
+            latestMessage: summary.latestMessage,
+            threadId: sessionId,
+            taskId: null,
+            resumeCommand: null,
+            url: null,
+            git: await gitForRoot(sourceRoot),
+            provenance: "hermes",
+            confidence: "typed",
+            needsUser: null,
+            liveSubscription: "readOnly",
+            network: null
+        });
+        events.push(...buildHermesHookEvents({ records, projectRoot: sourceRoot }));
+    }
+    return {
+        agents: agents
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .slice(0, limit),
+        events: events.sort((left, right) => right.createdAt.localeCompare(left.createdAt)),
+        notes: []
+    };
+}
+function summarizeHermesSessionForTest(input) {
+    return summarizeHermesSession({
+        session: input.session,
+        projectRoot: input.projectRoot,
+        cwd: input.cwd ?? input.projectRoot,
+        activeProcess: input.active
+            ? {
+                pid: 1,
+                cwd: input.cwd ?? input.projectRoot,
+                hermesHome: input.session.home,
+                command: "hermes",
+                updatedAtMs: input.now ?? Date.now()
+            }
+            : null,
+        paths: input.paths ?? [input.projectRoot],
+        now: input.now ?? Date.now()
+    });
+}
+function summarizeHermesHookSessionForTest(input) {
+    const now = input.now ?? Date.now();
+    return summarizeHermesHookSession({
+        records: input.records.map((record, index) => ({
+            sessionId: record.sessionId ?? "test-session",
+            eventName: record.eventName,
+            timestampMs: record.timestampMs ?? now + index,
+            cwd: record.cwd ?? input.projectRoot,
+            processCwd: record.processCwd ?? input.projectRoot,
+            payload: record.payload,
+            raw: record.raw ?? {}
+        })),
+        projectRoot: input.projectRoot,
+        paths: input.paths ?? [input.projectRoot],
+        now
+    });
+}
+function isHermesGatewayDaemonForTest(argv) {
+    return looksLikeHermesGatewayDaemon(argv);
+}
+function isHermesRuntimeHomeProcessForTest(argv, cwd) {
+    return looksLikeHermesRuntimeHomeProcess(argv, cwd);
+}
+function isHermesCompressionContinuationForTest(input) {
+    return isHermesCompressionContinuation({
+        id: "test-session",
+        source: "cli",
+        model: null,
+        parentSessionId: input.parentSessionId ?? null,
+        parentEndedAt: input.parentEndedAt ?? null,
+        parentEndReason: input.parentEndReason ?? null,
+        startedAt: input.startedAt ?? 0,
+        endedAt: null,
+        endReason: null,
+        messageCount: 0,
+        toolCallCount: 0,
+        title: null,
+        systemPrompt: null,
+        lastActive: input.startedAt ?? 0,
+        home: "/tmp/hermes",
+        storage: "sqlite",
+        messages: []
+    });
+}
+async function currentHermesSessionProjectRootForTest(input) {
+    return currentProjectRootForHermesSession(input.session, input.activeCwd
+        ? {
+            pid: 1,
+            cwd: input.activeCwd,
+            hermesHome: input.session.home,
+            command: "hermes",
+            updatedAtMs: Date.now()
+        }
+        : null);
+}
+//# sourceMappingURL=hermes.js.map