nmem-cli 0.9.4__tar.gz → 0.9.8__tar.gz

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.9.4
+Version: 0.9.8
 Summary: CLI and TUI for Nowledge Mem - AI memory management
 Project-URL: Homepage, https://mem.nowledge.co/
 Project-URL: Repository, https://github.com/nowledge-co/
@@ -118,10 +118,14 @@ nmem t
 | `nmem t append <id> -m '[{"role":"user","content":"..."}]'` | Append messages to a thread |
 | `nmem t save --from claude-code` | Save Claude Code session as thread |
 | `nmem t save --from codex` | Save Codex session as thread |
+| `nmem t save --from cursor` | Save the latest Cursor Agent session for this project |
 | `nmem t save --from gemini-cli` | Save Gemini CLI session as thread |
 | `nmem t sync --from codex --all-projects` | Preview historical Codex sessions across projects |
+| `nmem t sync --from cursor --all-projects` | Preview historical Cursor Agent sessions |
 | `nmem t sync --from pi` | Preview historical Pi sessions |
 | `nmem t sync --from pi --apply` | Import historical Pi sessions |
+| `nmem t sync --from hermes` | Preview historical Hermes sessions from `~/.hermes/state.db` |
+| `nmem t sync --from hermes --apply` | Import historical Hermes sessions |
 | `nmem t delete <id>` | Delete a thread |
 | `nmem t delete <id> --dry-run` | Preview what would be deleted |
 
@@ -350,7 +354,7 @@ nmem t append openclaw-session-abc123 \
 
 ### Saving AI Coding Sessions
 
-Import conversations from Claude Code, Codex, Gemini CLI, OpenCode, or Pi as threads:
+Import conversations from Claude Code, Codex, Cursor, Gemini CLI, OpenCode, or Pi as threads:
 
 ```bash
 # Save current Claude Code session (uses current directory)
@@ -365,6 +369,9 @@ nmem t save --from claude-code -m all
 # Save Codex session with a summary
 nmem t save --from codex -s "Implemented auth feature"
 
+# Save latest Cursor Agent session for this project
+nmem t save --from cursor
+
 # Save Gemini CLI session from the current project
 nmem t save --from gemini-cli
 
@@ -372,8 +379,18 @@ nmem t save --from gemini-cli
 nmem t sync --from pi
 nmem t sync --from pi --apply
 
+# Preview older Hermes sessions from ~/.hermes/state.db, then import them
+nmem t sync --from hermes
+nmem t sync --from hermes --apply
+
+# Preview older Cursor Agent sessions, then import them
+nmem t sync --from cursor --all-projects
+nmem t sync --from cursor --all-projects --apply
+nmem t sync --from cursor --session-dir ~/.cursor/projects/Users-me-project/agent-transcripts --apply
+
 # Preview older sessions across all projects for hosts with project-scoped storage
 nmem t sync --from codex --all-projects --limit 20
+nmem t sync --from cursor --all-projects --limit 20
 nmem t sync --from claude-code --all-projects --limit 20
 nmem t sync --from gemini-cli --all-projects --limit 20
 nmem t sync --from opencode --all-projects --limit 20
@@ -385,29 +402,29 @@ How it works:
 - it parses those transcripts into normalized thread messages
 - it then uploads the resulting thread data to your configured Mem server
 
-By default, Claude Code, Codex, and Pi are discovered from `~/.claude`, `~/.codex`, and `~/.pi/agent`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, and `PI_CODING_AGENT_SESSION_DIR` automatically.
+By default, Claude Code, Codex, Cursor, Pi, and Hermes are discovered from `~/.claude`, `~/.codex`, `~/.cursor/projects`, `~/.pi/agent`, and `~/.hermes/state.db`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, `PI_CODING_AGENT_SESSION_DIR`, and `HERMES_HOME` automatically.
 
-That means `nmem t save --from ...` works correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
+That means `nmem t save --from ...` and `nmem t sync --from ...` work correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
 
 Options:
-- `--from`: Source app (`claude-code`, `codex`, `gemini-cli`, `opencode`, or `pi`) - required
+- `--from`: Source app (`claude-code`, `codex`, `cursor`, `gemini-cli`, `opencode`, `pi`, or `hermes`) - required
 - `-p, --project`: Project directory (default: current dir)
 - `-m, --mode`: `current` (latest session) or `all` (all sessions)
 - `-s, --summary`: Brief session summary
 - `--session-id`: Specific session ID
 - `--truncate`: Truncate large tool results (>10KB)
 
-Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi, `sync` scans all Pi sessions by default; pass `--session-dir` or `--project` to narrow it. For Claude Code, Codex, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
+Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi and Hermes, `sync` scans all local sessions by default; pass `--session-dir` to point at a Cursor `agent-transcripts` folder, a Cursor Agent JSONL file, a Pi sessions folder, a Pi JSONL file, a Hermes home folder, or a Hermes `state.db`. For Claude Code, Codex, Cursor, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
 
 Re-running the command is safe. Each discovered session is processed independently. If a previous run stopped halfway through a batch, or created a thread but stopped before the batch finished, the next run detects the existing thread and appends with deduplication. If another process creates the thread between the existence check and the create request, the command falls through to the same deduplicated append path. Stable thread IDs, stable per-message `external_id`s, and an idempotency key keep repeated imports from duplicating messages.
 
 This import path is distinct from desktop auto-sync and watcher-based ingestion:
 
-- desktop auto-sync watches transcript files on the same machine as the Mem server
+- desktop auto-sync watches supported local transcript stores on the same machine as the Mem server
 - plugin hooks and `nmem t save` / `nmem t sync` run on the machine where the agent is running, then upload to local or remote Mem through the same client config
 - all paths use the same canonical source and thread IDs, so rerunning a hook, desktop watcher, or historical sync appends to the same thread instead of creating duplicates
 
-Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, or OpenCode session database by itself.
+Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, `~/.hermes/state.db`, or OpenCode session database by itself.
 
 ## Related
 

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/README.md

@@ -85,10 +85,14 @@ nmem t
 | `nmem t append <id> -m '[{"role":"user","content":"..."}]'` | Append messages to a thread |
 | `nmem t save --from claude-code` | Save Claude Code session as thread |
 | `nmem t save --from codex` | Save Codex session as thread |
+| `nmem t save --from cursor` | Save the latest Cursor Agent session for this project |
 | `nmem t save --from gemini-cli` | Save Gemini CLI session as thread |
 | `nmem t sync --from codex --all-projects` | Preview historical Codex sessions across projects |
+| `nmem t sync --from cursor --all-projects` | Preview historical Cursor Agent sessions |
 | `nmem t sync --from pi` | Preview historical Pi sessions |
 | `nmem t sync --from pi --apply` | Import historical Pi sessions |
+| `nmem t sync --from hermes` | Preview historical Hermes sessions from `~/.hermes/state.db` |
+| `nmem t sync --from hermes --apply` | Import historical Hermes sessions |
 | `nmem t delete <id>` | Delete a thread |
 | `nmem t delete <id> --dry-run` | Preview what would be deleted |
 
@@ -317,7 +321,7 @@ nmem t append openclaw-session-abc123 \
 
 ### Saving AI Coding Sessions
 
-Import conversations from Claude Code, Codex, Gemini CLI, OpenCode, or Pi as threads:
+Import conversations from Claude Code, Codex, Cursor, Gemini CLI, OpenCode, or Pi as threads:
 
 ```bash
 # Save current Claude Code session (uses current directory)
@@ -332,6 +336,9 @@ nmem t save --from claude-code -m all
 # Save Codex session with a summary
 nmem t save --from codex -s "Implemented auth feature"
 
+# Save latest Cursor Agent session for this project
+nmem t save --from cursor
+
 # Save Gemini CLI session from the current project
 nmem t save --from gemini-cli
 
@@ -339,8 +346,18 @@ nmem t save --from gemini-cli
 nmem t sync --from pi
 nmem t sync --from pi --apply
 
+# Preview older Hermes sessions from ~/.hermes/state.db, then import them
+nmem t sync --from hermes
+nmem t sync --from hermes --apply
+
+# Preview older Cursor Agent sessions, then import them
+nmem t sync --from cursor --all-projects
+nmem t sync --from cursor --all-projects --apply
+nmem t sync --from cursor --session-dir ~/.cursor/projects/Users-me-project/agent-transcripts --apply
+
 # Preview older sessions across all projects for hosts with project-scoped storage
 nmem t sync --from codex --all-projects --limit 20
+nmem t sync --from cursor --all-projects --limit 20
 nmem t sync --from claude-code --all-projects --limit 20
 nmem t sync --from gemini-cli --all-projects --limit 20
 nmem t sync --from opencode --all-projects --limit 20
@@ -352,29 +369,29 @@ How it works:
 - it parses those transcripts into normalized thread messages
 - it then uploads the resulting thread data to your configured Mem server
 
-By default, Claude Code, Codex, and Pi are discovered from `~/.claude`, `~/.codex`, and `~/.pi/agent`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, and `PI_CODING_AGENT_SESSION_DIR` automatically.
+By default, Claude Code, Codex, Cursor, Pi, and Hermes are discovered from `~/.claude`, `~/.codex`, `~/.cursor/projects`, `~/.pi/agent`, and `~/.hermes/state.db`. If you keep them somewhere else, `nmem` also respects `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`, `PI_CODING_AGENT_SESSION_DIR`, and `HERMES_HOME` automatically.
 
-That means `nmem t save --from ...` works correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
+That means `nmem t save --from ...` and `nmem t sync --from ...` work correctly with remote Mem too: the server does not need direct access to those local agent directories on your laptop.
 
 Options:
-- `--from`: Source app (`claude-code`, `codex`, `gemini-cli`, `opencode`, or `pi`) - required
+- `--from`: Source app (`claude-code`, `codex`, `cursor`, `gemini-cli`, `opencode`, `pi`, or `hermes`) - required
 - `-p, --project`: Project directory (default: current dir)
 - `-m, --mode`: `current` (latest session) or `all` (all sessions)
 - `-s, --summary`: Brief session summary
 - `--session-id`: Specific session ID
 - `--truncate`: Truncate large tool results (>10KB)
 
-Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi, `sync` scans all Pi sessions by default; pass `--session-dir` or `--project` to narrow it. For Claude Code, Codex, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
+Use `nmem t sync --from ...` for deliberate historical backfills. It previews by default and requires `--apply` before writing. For Pi and Hermes, `sync` scans all local sessions by default; pass `--session-dir` to point at a Cursor `agent-transcripts` folder, a Cursor Agent JSONL file, a Pi sessions folder, a Pi JSONL file, a Hermes home folder, or a Hermes `state.db`. For Claude Code, Codex, Cursor, Gemini CLI, and OpenCode, the default stays scoped to the current project; add `--all-projects` when you intentionally want a broader import.
 
 Re-running the command is safe. Each discovered session is processed independently. If a previous run stopped halfway through a batch, or created a thread but stopped before the batch finished, the next run detects the existing thread and appends with deduplication. If another process creates the thread between the existence check and the create request, the command falls through to the same deduplicated append path. Stable thread IDs, stable per-message `external_id`s, and an idempotency key keep repeated imports from duplicating messages.
 
 This import path is distinct from desktop auto-sync and watcher-based ingestion:
 
-- desktop auto-sync watches transcript files on the same machine as the Mem server
+- desktop auto-sync watches supported local transcript stores on the same machine as the Mem server
 - plugin hooks and `nmem t save` / `nmem t sync` run on the machine where the agent is running, then upload to local or remote Mem through the same client config
 - all paths use the same canonical source and thread IDs, so rerunning a hook, desktop watcher, or historical sync appends to the same thread instead of creating duplicates
 
-Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, or OpenCode session database by itself.
+Use the client-side path for remote Mem. A remote Mem server cannot scan your laptop's `~/.codex`, `~/.claude`, `~/.gemini`, `~/.pi`, `~/.hermes/state.db`, or OpenCode session database by itself.
 
 ## Related
 

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nmem-cli"
-version = "0.9.4"
+version = "0.9.8"
 description = "CLI and TUI for Nowledge Mem - AI memory management"
 authors = [
     {name = "Nowledge Labs"}

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/src/nmem_cli/__init__.py

@@ -20,7 +20,7 @@ Environment (overrides config file):
     NMEM_API_KEY         Optional API key (Bearer auth)
 """
 
-__version__ = "0.9.4"
+__version__ = "0.9.8"
 __author__ = "Nowledge Labs"
 
 from .cli import main

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/src/nmem_cli/cli.py

@@ -87,6 +87,10 @@ SUPPORTED_PROVIDER_TYPES = [
     "openai_compatible",
 ]
 
+DEFAULT_MAX_TOKENS_PER_HOUR = 5_000_000
+DEFAULT_MAX_TOKENS_PER_DAY = 10_000_000
+DEFAULT_MAX_TOKENS_PER_TASK = 2_000_000
+
 PROVIDER_OPTIONS = [
     ("OpenAI (`openai`)", "openai"),
     ("Anthropic (`anthropic`)", "anthropic"),
@@ -5370,13 +5374,14 @@ def cmd_threads_sync(
             print_error("Conflicting Scope", data["message"])
         sys.exit(1)
 
-    # Pi can safely preview all projects by default. Other clients historically
-    # key discovery by project path, so keep their default scoped to cwd.
+    # Pi and Hermes have one local session store, so they can safely preview all
+    # sessions by default. Cursor stays cwd-scoped unless the caller gives an
+    # explicit transcript root; then the root itself is the user's selected scope.
     discovery_path = project_path
     if all_projects:
         discovery_path = "__all__"
     elif discovery_path is None:
-        discovery_path = "*" if client == "pi" else "."
+        discovery_path = "*" if client in {"pi", "hermes"} or (client == "cursor" and source_roots) else "."
     resolved_path = (
         Path(discovery_path).expanduser().absolute()
         if discovery_path not in {"", "*", "__all__"}
@@ -9218,9 +9223,9 @@ def cmd_config_settings_show() -> None:
     console.print(f"  KG Extraction Confidence:    {settings.get('kgExtractionConfidence', 0.7)}")
 
     # Token budget
-    max_hour = settings.get("maxTokensPerHour", 500_000)
-    max_day = settings.get("maxTokensPerDay", 2_000_000)
-    max_task = settings.get("maxTokensPerTask", 500_000)
+    max_hour = settings.get("maxTokensPerHour", DEFAULT_MAX_TOKENS_PER_HOUR)
+    max_day = settings.get("maxTokensPerDay", DEFAULT_MAX_TOKENS_PER_DAY)
+    max_task = settings.get("maxTokensPerTask", DEFAULT_MAX_TOKENS_PER_TASK)
     console.print(f"  Max Tokens/Hour:             {_format_tokens(max_hour)}")
     console.print(f"  Max Tokens/Day:              {_format_tokens(max_day)}")
     console.print(f"  Max Tokens/Task:             {_format_tokens(max_task)}")
@@ -10585,12 +10590,13 @@ PRIORITY
         # save - Save coding session as thread
         sv = thr_subs.add_parser(
             "save",
-            help="Save Claude Code, Codex, Gemini CLI, OpenCode, or Pi session as thread",
+            help="Save Claude Code, Codex, Cursor, Gemini CLI, OpenCode, or Pi session as thread",
             parents=[_space_parent],
             epilog="""examples:
   nmem t save --from claude-code
   nmem t save --from claude-code -p /path/to/project -m all
   nmem t save --from codex --session-id sess_abc123
+  nmem t save --from cursor -p /path/to/project
   nmem t save --from opencode -p /path/to/project
   nmem t save --from pi -p /path/to/project
   nmem t save --from gemini-cli --summary "Refactored auth module" """,
@@ -10635,8 +10641,11 @@ PRIORITY
             epilog="""examples:
   nmem t sync --from pi
   nmem t sync --from pi --apply
+  nmem t sync --from cursor --all-projects --limit 20
+  nmem t sync --from hermes --apply
   nmem t sync --from codex --all-projects --limit 20
-  nmem t sync --from pi --session-dir ~/.pi/agent/sessions --limit 20
+  nmem t sync --from cursor --session-dir ~/.cursor/projects/Users-me-project/agent-transcripts --apply
+  nmem t sync --from hermes --session-dir ~/.hermes/state.db --limit 20
   nmem t sync --from codex -p /path/to/project --apply""",
             formatter_class=argparse.RawDescriptionHelpFormatter,
         )
@@ -10652,8 +10661,8 @@ PRIORITY
             "--project",
             default=None,
             help=(
-                "Project directory path. Defaults to all Pi sessions for Pi, "
-                "and current directory for other clients."
+                "Project directory path. Defaults to all Pi/Hermes sessions for "
+                "Pi and Hermes, and current directory for other clients."
             ),
         )
         sync.add_argument(
@@ -10672,7 +10681,10 @@ PRIORITY
             "--session-dir",
             dest="session_dirs",
             action="append",
-            help="Pi session directory or JSONL file to scan. May be repeated.",
+            help=(
+                "Cursor/Pi session directory/JSONL file or Hermes state.db/Hermes home "
+                "to scan. May be repeated."
+            ),
         )
         sync.add_argument(
             "--truncate",

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/src/nmem_cli/session_import.py

@@ -6,8 +6,9 @@ published separately on PyPI and must remain able to perform remote-safe capture
 without importing server internals.
 
 Maintenance rule:
-- if Claude Code, Codex, Gemini CLI, OpenCode, or Pi change their transcript
-  formats or storage layout, update this client module and the corresponding
+- if Claude Code, Codex/Cursor, Gemini CLI, OpenCode, Pi, or Hermes change
+  their transcript formats or storage layout, update this client module and
+  the corresponding
   server-local parser/import path in the same change
 - keep the normalized thread output aligned across both sides
 """
@@ -30,7 +31,15 @@ from .claude_paths import find_valid_claude_path
 
 logger = logging.getLogger(__name__)
 
-SUPPORTED_SESSION_CLIENTS = ("claude-code", "codex", "gemini-cli", "opencode", "pi")
+SUPPORTED_SESSION_CLIENTS = (
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini-cli",
+    "opencode",
+    "pi",
+    "hermes",
+)
 SUPPORTED_SESSION_CLIENTS_TEXT = ", ".join(SUPPORTED_SESSION_CLIENTS)
 _ALL_PROJECT_SENTINELS = {"", "*", "__all__"}
 
@@ -54,6 +63,7 @@ _KNOWN_TITLE_SCAFFOLD_PREFIXES = (
 )
 
 _KNOWN_HOST_SCAFFOLD_TAG_PREFIXES = (
+    "<user_query>",
     "<environment_context>",
     "<permissions instructions>",
     "<apps_instructions>",
@@ -206,12 +216,16 @@ def discover_sessions(
         candidates = _discover_claude_sessions(project_path, session_id)
     elif client == "codex":
         candidates = _discover_codex_sessions(project_path, session_id)
+    elif client == "cursor":
+        candidates = _discover_cursor_sessions(project_path, session_id, source_roots)
     elif client == "gemini-cli":
         candidates = _discover_gemini_sessions(project_path, session_id)
     elif client == "opencode":
         candidates = _discover_opencode_sessions(project_path, session_id)
     elif client == "pi":
         candidates = _discover_pi_sessions(project_path, session_id, source_roots)
+    elif client == "hermes":
+        candidates = _discover_hermes_sessions(project_path, session_id, source_roots)
     else:
         raise SessionImportError(
             f"Unsupported client: {client}. Supported: {SUPPORTED_SESSION_CLIENTS_TEXT}"
@@ -233,12 +247,20 @@ def parse_session(
         return parse_claude_code_session_streaming(file_path, truncate_large_content)
     if client == "codex":
         return parse_codex_session_streaming(file_path, truncate_large_content)
+    if client == "cursor":
+        return parse_cursor_agent_session(file_path)
     if client == "gemini-cli":
         return parse_gemini_session(file_path)
     if client == "opencode":
         return parse_opencode_session(file_path, session_id=session_id)
     if client == "pi":
         return parse_pi_session(file_path)
+    if client == "hermes":
+        return parse_hermes_session(
+            file_path,
+            session_id=session_id,
+            truncate_large_content=truncate_large_content,
+        )
     raise SessionImportError(
         f"Unsupported client: {client}. Supported: {SUPPORTED_SESSION_CLIENTS_TEXT}"
     )
@@ -409,6 +431,165 @@ def _discover_codex_sessions(
     return candidates
 
 
+def _get_cursor_agent_projects_dir() -> Path:
+    return Path.home() / ".cursor" / "projects"
+
+
+def _encode_cursor_project_path(project_path: str) -> str:
+    normalized = os.path.normpath(os.path.expanduser(project_path))
+    if sys.platform == "win32" and ":\\" in normalized:
+        return normalized.replace(":\\", "--").replace("\\", "-")
+    return normalized.lstrip("/").replace("/", "-")
+
+
+def _cursor_project_name(project_encoded: str | None) -> str | None:
+    if not project_encoded:
+        return None
+    parts = [part for part in project_encoded.split("-") if part]
+    return parts[-1] if parts else project_encoded
+
+
+def _cursor_project_dir_for_transcript(
+    transcript_path: Path,
+    projects_root: Path,
+) -> Optional[Path]:
+    try:
+        relative = transcript_path.relative_to(projects_root)
+    except ValueError:
+        return None
+    if not relative.parts:
+        return None
+    return projects_root / relative.parts[0]
+
+
+def _get_cursor_agent_roots(source_roots: Optional[list[str]] = None) -> list[Path]:
+    if source_roots:
+        roots: list[Path] = []
+        for root in source_roots:
+            candidate = Path(root).expanduser()
+            if candidate.is_file() and candidate.suffix == ".jsonl":
+                roots.append(candidate)
+            elif candidate.name == "agent-transcripts":
+                roots.append(candidate)
+            elif (candidate / "agent-transcripts").exists():
+                roots.append(candidate / "agent-transcripts")
+            else:
+                roots.append(candidate)
+        return roots
+    return [_get_cursor_agent_projects_dir()]
+
+
+def _iter_cursor_agent_jsonl_files(
+    source_roots: Optional[list[str]] = None,
+) -> list[Path]:
+    files: list[Path] = []
+    for root in _get_cursor_agent_roots(source_roots):
+        if root.is_file() and root.suffix == ".jsonl":
+            files.append(root)
+        elif root.name == "agent-transcripts":
+            files.extend(path for path in root.glob("**/*.jsonl") if path.is_file())
+        else:
+            files.extend(
+                path
+                for path in root.glob("*/agent-transcripts/**/*.jsonl")
+                if path.is_file()
+            )
+    return files
+
+
+def _cursor_agent_message_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for item in content:
+        if not isinstance(item, dict):
+            continue
+        item_type = item.get("type")
+        if item_type == "text":
+            text = item.get("text")
+            if isinstance(text, str) and text.strip():
+                parts.append(text)
+        elif item_type == "tool_use":
+            tool_name = item.get("name") or item.get("tool") or "tool"
+            if isinstance(tool_name, str) and tool_name.strip():
+                parts.append(f"[Tool use: {tool_name.strip()}]")
+    return "\n".join(parts)
+
+
+def _discover_cursor_sessions(
+    project_path: str,
+    target_session_id: Optional[str],
+    source_roots: Optional[list[str]] = None,
+) -> list[SessionCandidate]:
+    all_projects = _is_all_projects_path(project_path)
+    expected_project_encoded = (
+        None if all_projects else _encode_cursor_project_path(project_path)
+    )
+    projects_root = _get_cursor_agent_projects_dir()
+    candidates: list[SessionCandidate] = []
+
+    for session_file in _iter_cursor_agent_jsonl_files(source_roots):
+        project_dir = _cursor_project_dir_for_transcript(session_file, projects_root)
+        project_encoded = project_dir.name if project_dir else None
+        if expected_project_encoded and project_encoded != expected_project_encoded:
+            continue
+
+        file_session_id = session_file.stem
+        if target_session_id and file_session_id != target_session_id:
+            continue
+
+        user_messages = 0
+        assistant_messages = 0
+        try:
+            with open(session_file, "r", encoding="utf-8") as handle:
+                for line in handle:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        record = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if not isinstance(record, dict):
+                        continue
+                    role = record.get("role")
+                    message = record.get("message")
+                    content = (
+                        message.get("content") if isinstance(message, dict) else None
+                    )
+                    if not _cursor_agent_message_text(content).strip():
+                        continue
+                    if role == "user":
+                        user_messages += 1
+                    elif role == "assistant":
+                        assistant_messages += 1
+        except Exception as exc:
+            logger.warning(
+                "Failed to analyze Cursor Agent transcript %s: %s",
+                session_file,
+                exc,
+            )
+            continue
+
+        if user_messages + assistant_messages <= 0:
+            continue
+
+        candidates.append(
+            SessionCandidate(
+                file=session_file,
+                session_id=file_session_id,
+                sort_key=session_file.stat().st_mtime,
+                user_messages=user_messages,
+                assistant_messages=assistant_messages,
+            )
+        )
+
+    candidates.sort(key=lambda s: (s.sort_key, s.file.stat().st_mtime), reverse=True)
+    return candidates
+
+
 def _discover_gemini_sessions(
     project_path: str, target_session_id: Optional[str]
 ) -> list[SessionCandidate]:
@@ -699,6 +880,31 @@ def _get_pi_session_roots(source_roots: Optional[list[str]] = None) -> list[Path
     return roots
 
 
+def _get_hermes_db_paths(source_roots: Optional[list[str]] = None) -> list[Path]:
+    paths: list[Path] = []
+
+    def add(candidate: str | Path | None) -> None:
+        if candidate is None:
+            return
+        path = Path(candidate).expanduser()
+        if path.is_dir():
+            path = path / "state.db"
+        if path not in paths:
+            paths.append(path)
+
+    if source_roots:
+        for root in source_roots:
+            add(root)
+        return paths
+
+    hermes_home = os.environ.get("HERMES_HOME", "").strip()
+    if hermes_home:
+        add(Path(hermes_home) / "state.db")
+
+    add(Path.home() / ".hermes" / "state.db")
+    return paths
+
+
 def _iter_pi_jsonl_files(source_roots: Optional[list[str]] = None) -> list[Path]:
     seen: set[Path] = set()
     files: list[Path] = []
@@ -825,6 +1031,91 @@ def _discover_pi_sessions(
     return candidates
 
 
+def _safe_hermes_sqlite_connect(db_path: Path) -> Optional[sqlite3.Connection]:
+    max_retries = 3
+    delays = [0.1, 0.2, 0.4]
+
+    for attempt in range(max_retries):
+        try:
+            conn = sqlite3.connect(
+                f"file:{db_path}?mode=ro",
+                timeout=5,
+                uri=True,
+            )
+            conn.row_factory = sqlite3.Row
+            return conn
+        except sqlite3.OperationalError as exc:
+            if "database is locked" in str(exc) and attempt < max_retries - 1:
+                time.sleep(delays[attempt])
+                continue
+            logger.warning("Failed to connect to Hermes database %s: %s", db_path, exc)
+            return None
+        except Exception as exc:
+            logger.warning(
+                "Unexpected error connecting to Hermes database %s: %s",
+                db_path,
+                exc,
+            )
+            return None
+
+    return None
+
+
+def _discover_hermes_sessions(
+    project_path: str,
+    target_session_id: Optional[str],
+    source_roots: Optional[list[str]] = None,
+) -> list[SessionCandidate]:
+    del project_path
+    candidates: list[SessionCandidate] = []
+    seen_session_ids: set[str] = set()
+
+    for db_path in _get_hermes_db_paths(source_roots):
+        if not db_path.exists() or not db_path.is_file():
+            continue
+        conn = _safe_hermes_sqlite_connect(db_path)
+        if conn is None:
+            continue
+        try:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT id, started_at, ended_at, message_count
+                FROM sessions
+                WHERE (? IS NULL OR id = ?)
+                ORDER BY COALESCE(ended_at, started_at) DESC
+                """,
+                (target_session_id, target_session_id),
+            )
+            for row in cursor.fetchall():
+                session_id = str(row["id"] or "")
+                if not session_id or session_id in seen_session_ids:
+                    continue
+
+                message_count = int(row["message_count"] or 0)
+                if message_count <= 0:
+                    continue
+
+                sort_key = float(row["ended_at"] or row["started_at"] or 0.0)
+                candidates.append(
+                    SessionCandidate(
+                        file=db_path,
+                        session_id=session_id,
+                        sort_key=sort_key,
+                        user_messages=message_count,
+                    )
+                )
+                seen_session_ids.add(session_id)
+        except sqlite3.Error as exc:
+            logger.warning("Failed to discover Hermes sessions in %s: %s", db_path, exc)
+            continue
+        finally:
+            conn.close()
+
+    candidates.sort(key=lambda s: (s.sort_key, s.file.stat().st_mtime), reverse=True)
+    return candidates
+
+
 def _resolve_gemini_chats_dir(project_path: str) -> Optional[Path]:
     dirs = _resolve_gemini_chats_dirs(project_path)
     return dirs[0] if dirs else None
@@ -1014,6 +1305,89 @@ def parse_codex_session_streaming(
     }
 
 
+def parse_cursor_agent_session(file_path: Path) -> dict[str, Any]:
+    messages: list[dict[str, Any]] = []
+    first_user_content: Optional[str] = None
+    session_id = file_path.stem
+    projects_root = _get_cursor_agent_projects_dir()
+    project_dir = _cursor_project_dir_for_transcript(file_path, projects_root)
+    project_encoded = project_dir.name if project_dir else None
+    project_name = _cursor_project_name(project_encoded)
+
+    with open(file_path, "r", encoding="utf-8") as handle:
+        for line_num, line in enumerate(handle, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                logger.warning(
+                    "Skipping invalid Cursor Agent JSON on line %s",
+                    line_num,
+                )
+                continue
+            if not isinstance(record, dict):
+                continue
+
+            role = record.get("role")
+            if role not in {"user", "assistant"}:
+                continue
+
+            message = record.get("message")
+            content = message.get("content") if isinstance(message, dict) else None
+            content_text = _cursor_agent_message_text(content).strip()
+            if not content_text:
+                continue
+
+            if (
+                role == "user"
+                and not first_user_content
+                and not _is_poor_title_source(content_text)
+            ):
+                first_user_content = content_text
+
+            messages.append(
+                {
+                    "role": role,
+                    "content": content_text,
+                    "timestamp": record.get("timestamp"),
+                    "metadata": {
+                        "cursor_agent_transcript": True,
+                        "line": line_num,
+                    },
+                }
+            )
+
+    if not messages:
+        raise SessionImportError(
+            "No valid user/assistant messages found in Cursor Agent transcript"
+        )
+
+    title = "Cursor Agent Session"
+    if first_user_content:
+        title = first_user_content[:60].replace("\n", " ").strip()
+        if len(first_user_content) > 60:
+            title += "..."
+    elif project_name:
+        title = f"Cursor Agent: {project_name}"
+
+    return {
+        "thread_id": f"cursor-{session_id}",
+        "title": title,
+        "messages": messages,
+        "source": "cursor",
+        "workspace": None,
+        "metadata": {
+            "session_id": session_id,
+            "project_encoded": project_encoded,
+            "project_name": project_name,
+            "transcript_format": "cursor_agent_jsonl",
+            "original_file_path": str(file_path),
+        },
+    }
+
+
 def parse_gemini_session(file_path: Path) -> dict[str, Any]:
     with open(file_path, "r", encoding="utf-8") as handle:
         conversation = json.load(handle)
@@ -1271,6 +1645,303 @@ def parse_pi_session(file_path: Path) -> dict[str, Any]:
     }
 
 
+def parse_hermes_session(
+    db_path: Path,
+    *,
+    session_id: Optional[str],
+    truncate_large_content: bool = False,
+) -> dict[str, Any]:
+    if not session_id:
+        raise SessionImportError("Hermes SQLite import requires a session_id")
+
+    conn = _safe_hermes_sqlite_connect(db_path)
+    if conn is None:
+        raise SessionImportError(f"Failed to connect to Hermes database: {db_path}")
+
+    try:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT
+                id,
+                source,
+                user_id,
+                model,
+                model_config,
+                parent_session_id,
+                started_at,
+                ended_at,
+                end_reason,
+                message_count,
+                tool_call_count,
+                input_tokens,
+                output_tokens,
+                cache_read_tokens,
+                cache_write_tokens,
+                reasoning_tokens,
+                billing_provider,
+                billing_base_url,
+                billing_mode,
+                estimated_cost_usd,
+                actual_cost_usd,
+                cost_status,
+                cost_source,
+                pricing_version,
+                title
+            FROM sessions
+            WHERE id = ?
+            """,
+            (session_id,),
+        )
+        session_row = cursor.fetchone()
+        if session_row is None:
+            raise SessionImportError(
+                f"Session not found in Hermes database: {session_id}"
+            )
+
+        cursor.execute(
+            """
+            SELECT
+                id,
+                role,
+                content,
+                tool_call_id,
+                tool_calls,
+                tool_name,
+                timestamp,
+                token_count,
+                finish_reason,
+                reasoning,
+                reasoning_details,
+                codex_reasoning_items
+            FROM messages
+            WHERE session_id = ?
+            ORDER BY timestamp ASC, id ASC
+            """,
+            (session_id,),
+        )
+
+        messages: list[dict[str, Any]] = []
+        first_user_content: Optional[str] = None
+        for row in cursor.fetchall():
+            message = _hermes_row_to_message(row, truncate_large_content)
+            if message is None:
+                continue
+            if (
+                message["role"] == "user"
+                and not first_user_content
+                and not _is_poor_title_source(message["content"])
+            ):
+                first_user_content = message["content"]
+            messages.append(message)
+
+        if not messages:
+            raise SessionImportError(
+                "No valid user/assistant/tool messages found in Hermes session"
+            )
+        if not any(message["role"] == "user" for message in messages):
+            raise SessionImportError("Hermes session needs at least one user message")
+
+        title = str(session_row["title"] or "").strip()
+        if not title:
+            title = _build_hermes_title(first_user_content, session_row)
+
+        hermes_source = session_row["source"]
+        return {
+            # Live Hermes provider uses the Hermes session id as the Mem thread
+            # id. Keep it so history sync appends to already captured sessions.
+            "thread_id": session_id,
+            "title": title,
+            "messages": messages,
+            "source": "hermes",
+            "project": str(hermes_source) if hermes_source else None,
+            "metadata": {
+                "session_id": session_id,
+                "hermes_session_id": session_id,
+                "hermes_source": hermes_source,
+                "user_id": session_row["user_id"],
+                "model": session_row["model"],
+                "model_config": _parse_json_maybe(session_row["model_config"]),
+                "parent_session_id": session_row["parent_session_id"],
+                "started_at": session_row["started_at"],
+                "ended_at": session_row["ended_at"],
+                "end_reason": session_row["end_reason"],
+                "message_count": session_row["message_count"],
+                "tool_call_count": session_row["tool_call_count"],
+                "input_tokens": session_row["input_tokens"],
+                "output_tokens": session_row["output_tokens"],
+                "cache_read_tokens": session_row["cache_read_tokens"],
+                "cache_write_tokens": session_row["cache_write_tokens"],
+                "reasoning_tokens": session_row["reasoning_tokens"],
+                "billing_provider": session_row["billing_provider"],
+                "billing_base_url": session_row["billing_base_url"],
+                "billing_mode": session_row["billing_mode"],
+                "estimated_cost_usd": session_row["estimated_cost_usd"],
+                "actual_cost_usd": session_row["actual_cost_usd"],
+                "cost_status": session_row["cost_status"],
+                "cost_source": session_row["cost_source"],
+                "pricing_version": session_row["pricing_version"],
+                "storage": "sqlite",
+                "original_file_path": str(db_path),
+            },
+        }
+    finally:
+        conn.close()
+
+
+def _hermes_row_to_message(
+    row: sqlite3.Row,
+    truncate_large_content: bool,
+) -> Optional[dict[str, Any]]:
+    original_role = str(row["role"] or "").strip()
+    if original_role == "session_meta":
+        return None
+
+    role = "user" if original_role == "user" else "assistant"
+    content = _hermes_message_content(row, truncate_large_content).strip()
+    if not content:
+        return None
+
+    message_id = str(row["id"])
+    metadata = {
+        "external_id": f"hermes-message-{message_id}",
+        "hermes_message_id": message_id,
+        "hermes_role": original_role,
+        "tool_call_id": row["tool_call_id"],
+        "tool_name": row["tool_name"],
+        "token_count": row["token_count"],
+        "finish_reason": row["finish_reason"],
+        "source_app": "hermes",
+    }
+    return {
+        "role": role,
+        "content": content,
+        "timestamp": row["timestamp"],
+        "metadata": {
+            key: value for key, value in metadata.items() if value is not None
+        },
+    }
+
+
+def _hermes_message_content(row: sqlite3.Row, truncate_large_content: bool) -> str:
+    role = str(row["role"] or "").strip()
+    content = _string_or_empty(row["content"])
+
+    if role == "tool":
+        return _format_hermes_tool_message(
+            content,
+            tool_name=_string_or_empty(row["tool_name"]),
+            truncate_large_content=truncate_large_content,
+        )
+
+    if content:
+        return _truncate_if_requested(content, truncate_large_content)
+
+    tool_calls = _string_or_empty(row["tool_calls"])
+    if tool_calls:
+        return _format_hermes_json_block(
+            "Hermes tool call",
+            tool_calls,
+            truncate_large_content=truncate_large_content,
+        )
+
+    reasoning = _string_or_empty(row["reasoning"])
+    if reasoning:
+        content = f"<thinking>{reasoning}</thinking>"
+        return _truncate_if_requested(content, truncate_large_content)
+
+    reasoning_details = _string_or_empty(row["reasoning_details"])
+    if reasoning_details:
+        return _format_hermes_json_block(
+            "Hermes reasoning",
+            reasoning_details,
+            truncate_large_content=truncate_large_content,
+        )
+
+    codex_reasoning_items = _string_or_empty(row["codex_reasoning_items"])
+    if codex_reasoning_items:
+        return _format_hermes_json_block(
+            "Hermes reasoning",
+            codex_reasoning_items,
+            truncate_large_content=truncate_large_content,
+        )
+
+    return ""
+
+
+def _format_hermes_tool_message(
+    content: str,
+    *,
+    tool_name: str,
+    truncate_large_content: bool,
+) -> str:
+    label = f"Hermes tool result: {tool_name}" if tool_name else "Hermes tool result"
+    if not content:
+        return f"[{label}]"
+
+    parsed = _parse_json_maybe(content)
+    if isinstance(parsed, dict):
+        for key in ("output", "result", "content", "text", "error"):
+            value = parsed.get(key)
+            if isinstance(value, str) and value.strip():
+                value = _truncate_if_requested(value.strip(), truncate_large_content)
+                return f"[{label}]\n{value}"
+        content = json.dumps(parsed, ensure_ascii=False)
+
+    return f"[{label}]\n{_truncate_if_requested(content, truncate_large_content)}"
+
+
+def _format_hermes_json_block(
+    label: str,
+    value: str,
+    *,
+    truncate_large_content: bool,
+) -> str:
+    parsed = _parse_json_maybe(value)
+    if parsed is not None:
+        try:
+            value = json.dumps(parsed, ensure_ascii=False)
+        except TypeError:
+            pass
+    return f"[{label}]\n{_truncate_if_requested(value, truncate_large_content)}"
+
+
+def _build_hermes_title(
+    first_user_content: Optional[str],
+    session_row: sqlite3.Row,
+) -> str:
+    if first_user_content:
+        title = first_user_content[:80].replace("\n", " ").strip()
+        if len(first_user_content) > 80:
+            title += "..."
+        if title:
+            return title
+
+    source = str(session_row["source"] or "").strip()
+    if source:
+        return f"Hermes {source} session"
+    return "Hermes session"
+
+
+def _parse_json_maybe(value: Any) -> Any:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        return json.loads(value)
+    except Exception:
+        return None
+
+
+def _string_or_empty(value: Any) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _truncate_if_requested(value: str, truncate_large_content: bool) -> str:
+    if not truncate_large_content or len(value) <= 10_000:
+        return value
+    return value[:10_000] + "\n\n[truncated by nmem t sync --truncate]"
+
+
 def parse_opencode_session(
     file_path: Path,
     *,

{nmem_cli-0.9.4 → nmem_cli-0.9.8}/src/nmem_cli/tui/screens/settings.py

@@ -66,6 +66,9 @@ PROVIDER_DEFAULTS: dict[str, dict[str, str]] = {
 }
 
 ACCESS_ANYWHERE_DOCS_URL = "https://mem.nowledge.co/docs/remote-access"
+DEFAULT_MAX_TOKENS_PER_HOUR = 5_000_000
+DEFAULT_MAX_TOKENS_PER_DAY = 10_000_000
+DEFAULT_MAX_TOKENS_PER_TASK = 2_000_000
 
 
 def _normalize_account_tunnel_url_input(value: str) -> str:
@@ -1919,9 +1922,9 @@ class SettingsScreen(VerticalScroll):
             # Get current limits from settings
             kp_data = await self.api_client.get_knowledge_processing_settings()
             settings = kp_data.get("settings", {})
-            max_hour = settings.get("maxTokensPerHour", 500_000)
-            max_day = settings.get("maxTokensPerDay", 2_000_000)
-            max_task = settings.get("maxTokensPerTask", 500_000)
+            max_hour = settings.get("maxTokensPerHour", DEFAULT_MAX_TOKENS_PER_HOUR)
+            max_day = settings.get("maxTokensPerDay", DEFAULT_MAX_TOKENS_PER_DAY)
+            max_task = settings.get("maxTokensPerTask", DEFAULT_MAX_TOKENS_PER_TASK)
 
             # Get current usage from agent status
             agent_data = await self.api_client.get_agent_status()