sessionpulse 0.1.0__py3-none-any.whl

sessionpulse/__init__.py

@@ -0,0 +1,3 @@
+"""Session Pulse: a local dashboard and panel icon for Claude Code sessions."""
+
+__version__ = "0.1.0"

sessionpulse/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

sessionpulse/cli.py

@@ -0,0 +1,158 @@
+"""Command line: sessionpulse <command>."""
+import argparse
+import json
+import socket
+import sys
+import webbrowser
+
+from . import __version__, config, followups, hook, install, reader, server, todos, tray
+
+
+def cmd_serve(cfg, args):
+    srv = server.make_server(cfg)
+    followups.start_worker(cfg)
+    print(f"Session Pulse on {cfg.url}\nOpen it with: sessionpulse open")
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+
+
+def cmd_tray(cfg, args):
+    tray.run(cfg)
+
+
+def cmd_open(cfg, args):
+    webbrowser.open(server.open_url(cfg))
+
+
+def cmd_hook(cfg, args):
+    return hook.run()
+
+
+def cmd_install(cfg, args):
+    try:
+        changed = install.install_hooks(cfg)
+    except install.SettingsError as exc:
+        sys.exit(f"error: {exc}")
+    print(("Added" if changed else "Already present:") +
+          f" SessionStart/SessionEnd hooks in {cfg.claude / 'settings.json'}")
+    if args.no_autostart:
+        return
+    missing = tray.available()
+    if missing:
+        print(f"Skipped login autostart: {missing}\nYou can still run: sessionpulse serve")
+        return
+    print(f"Panel icon will start at login ({install.enable_autostart()}).")
+    print("Start it now with: sessionpulse tray &")
+
+
+def cmd_uninstall(cfg, args):
+    try:
+        changed = install.uninstall_hooks(cfg)
+    except install.SettingsError as exc:
+        sys.exit(f"error: {exc}")
+    print("Removed Session Pulse hooks." if changed else "No Session Pulse hooks were installed.")
+    if install.disable_autostart():
+        print("Removed login autostart.")
+    print(f"Your data is kept in {cfg.data}; delete that folder to remove it.")
+
+
+def cmd_doctor(cfg, args):
+    ok = True
+
+    def line(good, text):
+        nonlocal ok
+        ok &= bool(good)
+        print(f"  {'ok ' if good else 'FIX'}  {text}")
+
+    print(f"Session Pulse {__version__}")
+    line(cfg.claude.is_dir(), f"Claude Code folder: {cfg.claude}")
+    line((cfg.claude / "sessions").is_dir(), "live-session files (sessions/)")
+    snap = reader.snapshot(cfg)
+    h = snap["health"]
+    line(h["files"] > 0, f"{h['files']} transcripts, {len(snap['sessions'])} sessions, "
+                         f"newest Claude Code {h['newest_cli'] or '?'}")
+    try:
+        inst = install.hooks_installed(cfg)
+        line(inst == set(install.EVENTS), "start/exit hooks installed" if inst == set(install.EVENTS)
+             else "start/exit hooks missing: run `sessionpulse install`")
+    except install.SettingsError as exc:
+        line(False, str(exc))
+    missing = tray.available()
+    print(f"  {'ok ' if not missing else '-- '}  {'panel icon available' if not missing else missing}")
+    with socket.socket() as s:
+        busy = s.connect_ex(("127.0.0.1", cfg.port)) == 0
+    print(f"  {'ok ' if busy else '-- '}  dashboard {'running' if busy else 'not running'} on {cfg.url}")
+    for w in h["warnings"]:
+        line(False, w)
+    return 0 if ok else 1
+
+
+def cmd_snapshot(cfg, args):
+    json.dump(reader.snapshot(cfg), sys.stdout, indent=1)
+
+
+def cmd_todo(cfg, args):
+    try:
+        if args.action == "add":
+            todos.apply(cfg, {"op": "add", "text": " ".join(args.text), "project": args.project})
+        elif args.action in ("done", "undo", "delete"):
+            for i in args.text:
+                todos.apply(cfg, {"op": args.action, "id": i})
+    except ValueError as exc:
+        sys.exit(f"error: {exc}")
+    items = todos.load(cfg)
+    show = [i for i in items if bool(i["done_at"]) == (args.action == "list-done")]
+    for i in show:
+        tag = f"  [{i['project']}]" if i.get("project") else ""
+        when = f"  done {i['done_at'][:10]}" if i["done_at"] else ""
+        print(f"{i['id']}  {i['text']}{tag}{when}")
+    if not show:
+        print("Nothing here." if args.action == "list-done" else "No open to-dos.")
+
+
+def cmd_followups(cfg, args):
+    if not followups.claude_bin(cfg):
+        sys.exit("error: the `claude` command was not found; set claude_command in config.toml")
+    try:
+        n, added, closed = followups.scan(cfg, days=args.days, idle_minutes=0 if args.now else None,
+                                          session=args.session, force=args.again,
+                                          log=lambda m: print(m, flush=True))
+    except (RuntimeError, OSError, ValueError) as exc:
+        sys.exit(f"error: {exc}")
+    print(f"Read {n} session(s): {added} follow-up(s) added, {closed} closed.")
+    if not cfg.followups:
+        print("Tip: add `followups = true` to ~/.config/sessionpulse/config.toml to do this automatically.")
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="sessionpulse", description=__doc__)
+    p.add_argument("--version", action="version", version=f"sessionpulse {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("install", help="add Claude Code hooks and login autostart") \
+       .add_argument("--no-autostart", action="store_true", help="only add the hooks")
+    sub.add_parser("uninstall", help="remove the hooks and autostart (keeps your data)")
+    sub.add_parser("tray", help="panel icon + dashboard server")
+    sub.add_parser("serve", help="dashboard server only")
+    sub.add_parser("open", help="open the dashboard in your browser")
+    sub.add_parser("doctor", help="check the setup and data formats")
+    sub.add_parser("snapshot", help="print the dashboard data as JSON")
+    t = sub.add_parser("todo", help="your to-do list: add, done, undo, delete, list, list-done")
+    t.add_argument("action", nargs="?", default="list",
+                   choices=["list", "list-done", "add", "done", "undo", "delete"])
+    t.add_argument("text", nargs="*", help="the to-do text (add) or item ids (done/undo/delete)")
+    t.add_argument("-p", "--project", help="tag the new to-do with a project")
+    f = sub.add_parser("followups", help="pick open follow-ups out of recent sessions with Claude")
+    f.add_argument("--days", type=int, help="look back this many days (default: followups_days)")
+    f.add_argument("--session", help="only this session id (or its first characters)")
+    f.add_argument("--now", action="store_true", help="include sessions that are still active")
+    f.add_argument("--again", action="store_true", help="re-read sessions already read")
+    sub.add_parser("hook", help=argparse.SUPPRESS)
+    args = p.parse_args(argv)
+    cfg = config.load()
+    return globals()[f"cmd_{args.cmd}"](cfg, args) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sessionpulse/config.py

@@ -0,0 +1,90 @@
+"""Settings, read from ~/.config/sessionpulse/config.toml when it exists.
+
+Every key is optional; the defaults below apply otherwise. Example file:
+
+    port = 8765
+    refresh_seconds = 5
+    claude_dir = "~/.claude"
+    gap_minutes = 30
+"""
+import os
+import secrets
+import tomllib
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+
+
+def _xdg(var, fallback):
+    return Path(os.environ.get(var) or Path.home() / fallback)
+
+
+CONFIG_DIR = _xdg("XDG_CONFIG_HOME", ".config") / "sessionpulse"
+DATA_DIR = _xdg("XDG_DATA_HOME", ".local/share") / "sessionpulse"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+def _default_claude_dir():
+    return os.environ.get("CLAUDE_CONFIG_DIR") or "~/.claude"
+
+
+@dataclass
+class Config:
+    port: int = 8765
+    refresh_seconds: int = 5
+    claude_dir: str = field(default_factory=_default_claude_dir)
+    data_dir: str = str(DATA_DIR)
+    # Active time: activity closer together than this counts as one block,
+    # and a block is never shorter than min_block_minutes.
+    gap_minutes: int = 30
+    min_block_minutes: int = 15
+    # Follow-ups: let Claude read quiet sessions and add their open items to your to-dos.
+    # Off by default because it runs `claude -p`, which counts toward your usage.
+    followups: bool = False
+    followups_model: str = "haiku"
+    followups_days: int = 30          # only sessions active in this many days
+    followups_idle_minutes: int = 20  # wait until a session has been quiet this long
+    followups_every_minutes: int = 5
+    followups_batch: int = 5          # sessions read per round
+    followups_parallel: int = 3       # sessions read at the same time
+    claude_command: str = ""          # path to `claude`, if it isn't on PATH
+
+    @property
+    def claude(self) -> Path:
+        return Path(self.claude_dir).expanduser()
+
+    @property
+    def data(self) -> Path:
+        return Path(self.data_dir).expanduser()
+
+    @property
+    def events_file(self) -> Path:
+        return self.data / "events.jsonl"
+
+    @property
+    def url(self) -> str:
+        return f"http://127.0.0.1:{self.port}"
+
+
+def load(path: Path = CONFIG_FILE) -> Config:
+    cfg = Config()
+    if path.exists():
+        with open(path, "rb") as f:
+            raw = tomllib.load(f)
+        known = {f.name for f in fields(Config)}
+        for k, v in raw.items():
+            if k in known:
+                setattr(cfg, k, v)
+    return cfg
+
+
+def token(cfg: Config) -> str:
+    """The dashboard's access token, created on first use (mode 600)."""
+    path = cfg.data / "token"
+    if path.exists():
+        return path.read_text().strip()
+    cfg.data.mkdir(parents=True, exist_ok=True)
+    tok = secrets.token_urlsafe(24)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    with os.fdopen(fd, "w") as f:
+        f.write(tok)
+    return tok

sessionpulse/followups.py

@@ -0,0 +1,273 @@
+"""Follow-ups: to-dos picked out of your sessions automatically.
+
+Sessions often end with work that can't be finished in them: something to do
+outside (call a vendor, check a site), an audit checklist, a decision you need
+to take, an answer you're waiting for. This module asks Claude to read a quiet
+session and list exactly those, then adds them to your to-do list, linked to the
+session. It also closes earlier follow-ups that a later session shows are done.
+
+It is off unless config.toml has `followups = true`, because it runs
+`claude -p` (counts toward your Claude usage) on your transcripts. Each run uses
+--no-session-persistence and disables all hooks, so it doesn't show up as a
+session, in the dashboard or in any timesheet hook of yours.
+"""
+import fcntl
+import json
+import os
+import re
+import shutil
+import subprocess
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from . import reader, todos
+
+KINDS = todos.KINDS
+DIGEST_CHARS = 60000   # how much of a transcript goes to the model
+USER_CHARS = 1200      # per prompt
+CLAUDE_CHARS = 2500    # per reply
+MAX_ITEMS = 12
+TIMEOUT = 180
+
+SYSTEM = """You read a transcript of a Claude Code session between a user and Claude and list the \
+follow-ups the user still has open when the session went quiet. Reply only with the JSON the schema asks for.
+
+A follow-up is something real and specific that was NOT finished in the session:
+- external: work outside this session (contact a person or vendor, visit or check something physically, \
+log in somewhere, send or sign something, buy or renew something)
+- checklist: audit, review or verification items the user has to go through
+- decision: a choice the user was asked to make, or deferred ("decide later", "waiting on you")
+- waiting: an answer, document or action expected from someone else
+- task: work to do in a later session (it was planned or promised but not done)
+
+Do not list: things completed in the session; Claude's own intermediate steps; vague ideas; general \
+advice; anything the user explicitly rejected. Merge duplicates. If nothing is open, return no items.
+
+Write each item as a short imperative the user would put on their own list (max 110 characters), in \
+English, naming the concrete thing ("Ask the vendor for the September invoice broken down by team"). \
+Put the reason or context in `detail` (max 200 characters). Never copy passwords, keys or tokens into items.
+
+You also get the user's currently open to-dos for this project, with ids. Put an id in `resolved` only \
+if this transcript clearly shows that item was completed. Do not repeat an open to-do as a new item, and \
+do not re-add anything listed under "dismissed"."""
+
+SCHEMA = {
+    "type": "object",
+    "properties": {
+        "items": {"type": "array", "maxItems": MAX_ITEMS, "items": {
+            "type": "object",
+            "properties": {"text": {"type": "string"}, "kind": {"type": "string", "enum": list(KINDS)},
+                           "detail": {"type": "string"}},
+            "required": ["text", "kind"]}},
+        "resolved": {"type": "array", "items": {"type": "string"}},
+    },
+    "required": ["items", "resolved"],
+}
+
+_state_lock = threading.Lock()
+status = {"running": False, "last_run": None, "last_error": None, "done": 0}
+
+
+# ---------- transcript digest ----------
+def digest(path, project="", limit=DIGEST_CHARS):
+    """The user prompts and Claude's prose replies, oldest first, trimmed to fit."""
+    parts = []
+    with open(path, errors="replace") as f:
+        for line in f:
+            try:
+                e = json.loads(line)
+            except ValueError:
+                continue
+            if not isinstance(e, dict) or e.get("isSidechain") or e.get("type") not in ("user", "assistant"):
+                continue
+            msg = e.get("message") if isinstance(e.get("message"), dict) else {}
+            body = reader.text_of(msg.get("content")).strip()
+            if not body or (e["type"] == "user" and reader.is_noise(body)):
+                continue
+            body = re.sub(r"\n{3,}", "\n\n", body)
+            cap = USER_CHARS if e["type"] == "user" else CLAUDE_CHARS
+            if len(body) > cap:
+                body = body[:cap // 2] + "\n[…]\n" + body[-cap // 2:]
+            when = str(e.get("timestamp", ""))[:16].replace("T", " ")
+            parts.append(f"### {'USER' if e['type'] == 'user' else 'CLAUDE'} {when}\n{body}")
+    text = "\n\n".join(parts)
+    if len(text) > limit:  # keep the opening request and the end, where open items get summed up
+        head = parts[0][:3000] if parts else ""
+        text = head + "\n\n[… earlier part of the session left out …]\n\n" + text[-(limit - len(head)):]
+    return f"Project: {project}\n\n{text}"
+
+
+# ---------- running claude ----------
+def claude_bin(cfg):
+    for c in (cfg.claude_command, shutil.which("claude"), str(Path.home() / ".local/bin/claude"),
+              str(Path.home() / ".claude/local/claude")):
+        if c and (os.sep not in c or Path(c).is_file()):
+            found = shutil.which(c) if os.sep not in c else c
+            if found:
+                return found
+    return None
+
+
+def ask_claude(cfg, prompt):
+    exe = claude_bin(cfg)
+    if not exe:
+        raise RuntimeError("the `claude` command was not found; set claude_command in config.toml")
+    work = cfg.data / "followups-cwd"
+    work.mkdir(parents=True, exist_ok=True)
+    cmd = [exe, "-p", "--model", cfg.followups_model, "--no-session-persistence", "--tools", "",
+           "--settings", json.dumps({"disableAllHooks": True}), "--system-prompt", SYSTEM,
+           "--output-format", "json", "--json-schema", json.dumps(SCHEMA)]
+    env = {**os.environ, "SESSIONPULSE_CHILD": "1"}
+    r = subprocess.run(cmd, input=prompt, capture_output=True, text=True, cwd=work, env=env, timeout=TIMEOUT)
+    try:
+        out = json.loads(r.stdout)
+    except ValueError:
+        raise RuntimeError(f"claude exited {r.returncode}: {(r.stderr or r.stdout).strip()[:300]}")
+    if out.get("is_error") or not isinstance(out.get("structured_output"), dict):
+        raise RuntimeError(f"claude returned an error: {str(out.get('result'))[:300]}")
+    return out["structured_output"]
+
+
+# ---------- state ----------
+def _state_path(cfg):
+    return cfg.data / "followups.json"
+
+
+def load_state(cfg):
+    try:
+        st = json.loads(_state_path(cfg).read_text())
+        return st if isinstance(st, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _save_state(cfg, st):
+    cfg.data.mkdir(parents=True, exist_ok=True)
+    tmp = _state_path(cfg).with_suffix(".tmp")
+    tmp.write_text(json.dumps(st, indent=1))
+    os.replace(tmp, _state_path(cfg))
+
+
+# ---------- one session ----------
+def process(cfg, sess, path):
+    """Extract follow-ups from one session and merge them into the to-do list."""
+    items = todos.load(cfg)
+    project = sess.get("project") or ""
+    open_ = [i for i in items if not i.get("done_at") and i.get("project") == project][:40]
+    dismissed = [d for d in todos.dismissed(cfg) if d.get("project") == project][-40:]
+    prompt = digest(path, project)
+    prompt += "\n\n## Open to-dos for this project\n" + (
+        "\n".join(f"- [{i['id']}] {i['text']}" for i in open_) or "(none)")
+    prompt += "\n\n## Dismissed (never re-add)\n" + (
+        "\n".join(f"- {d['text']}" for d in dismissed) or "(none)")
+    out = ask_claude(cfg, prompt)
+    return todos.merge_followups(cfg, sess, out.get("items") or [], out.get("resolved") or [])
+
+
+def candidates(cfg, snap, days=None, idle_minutes=None, force=False):
+    """Sessions worth (re)reading: recent, quiet for a while, and changed since last read."""
+    days = cfg.followups_days if days is None else days
+    idle = timedelta(minutes=cfg.followups_idle_minutes if idle_minutes is None else idle_minutes)
+    now = datetime.now().astimezone()
+    st = load_state(cfg)
+    out = []
+    for s in snap["sessions"]:
+        if not s.get("end") or not s.get("prompts") or not s.get("transcript"):
+            continue
+        end = datetime.fromisoformat(s["end"])
+        if now - end > timedelta(days=days) or now - end < idle or s.get("state") == "busy":
+            continue
+        try:
+            size = os.stat(s["transcript"]).st_size
+        except OSError:
+            continue
+        if not force and st.get(s["id"], {}).get("size") == size:
+            continue
+        out.append((s, size))
+    out.sort(key=lambda x: x[0]["end"])  # oldest first, so later sessions can close earlier items
+    return out
+
+
+class Busy(RuntimeError):
+    pass
+
+
+def scan(cfg, limit=None, days=None, idle_minutes=None, session=None, force=False, log=None):
+    """Read the sessions that need it. Returns (sessions read, items added, items closed).
+
+    Only one scan runs at a time across processes (the tray's worker and the CLI)."""
+    cfg.data.mkdir(parents=True, exist_ok=True)
+    with open(cfg.data / "followups.lock", "w") as lk:
+        try:
+            fcntl.flock(lk, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            raise Busy("another follow-up scan is running; try again when it finishes")
+        return _scan(cfg, limit, days, idle_minutes, session, force, log)
+
+
+def _scan(cfg, limit, days, idle_minutes, session, force, log):
+    with reader.lock:
+        snap = reader.snapshot(cfg)
+    todo = candidates(cfg, snap, days, idle_minutes, force or bool(session))
+    if session:
+        todo = [x for x in todo if x[0]["id"].startswith(session)]
+    if limit:
+        todo = todo[-limit:]
+    added = closed = 0
+    errors = []
+
+    def one(job):
+        n, (s, size) = job
+        try:
+            a, c = process(cfg, s, s["transcript"])
+        except (RuntimeError, OSError, ValueError, subprocess.TimeoutExpired) as exc:
+            errors.append(str(exc))
+            if log:
+                log(f"[{n}/{len(todo)}] {s['project']}: failed, will retry next time ({str(exc)[:120]})")
+            return 0, 0
+        with _state_lock:
+            st = load_state(cfg)
+            st[s["id"]] = {"size": size, "at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                           "added": a, "closed": c}
+            _save_state(cfg, st)
+        if log:
+            log(f"[{n}/{len(todo)}] {s['project']} · {s['end'][:16]} · +{a} new, {c} closed")
+        return a, c
+
+    # A few at a time: each request mostly waits on the model. Oldest first, so a later
+    # session usually gets to see (and close) what an earlier one left open.
+    with ThreadPoolExecutor(max_workers=max(1, cfg.followups_parallel)) as pool:
+        for a, c in pool.map(one, enumerate(todo, 1)):
+            added += a
+            closed += c
+    if errors and len(errors) == len(todo):
+        raise RuntimeError(errors[-1])
+    return len(todo), added, closed
+
+
+# ---------- background worker ----------
+def start_worker(cfg):
+    if not cfg.followups or os.environ.get("SESSIONPULSE_CHILD"):
+        return None
+
+    def loop():
+        time.sleep(30)
+        while True:
+            status["running"] = True
+            try:
+                status["done"] += scan(cfg, limit=cfg.followups_batch)[0]
+                status["last_error"] = None
+                status["last_run"] = datetime.now().astimezone().isoformat(timespec="seconds")
+            except Busy:
+                pass  # `sessionpulse followups` is running; it covers the same sessions
+            except Exception as exc:  # keep the worker alive; show the problem on the dashboard
+                status["last_error"] = str(exc)[:300]
+            status["running"] = False
+            time.sleep(cfg.followups_every_minutes * 60)
+
+    t = threading.Thread(target=loop, daemon=True, name="followups")
+    t.start()
+    return t

sessionpulse/hook.py

@@ -0,0 +1,39 @@
+"""`sessionpulse hook`: run by Claude Code on SessionStart and SessionEnd.
+
+Appends one line to <data_dir>/events.jsonl. It must never fail loudly or
+slow the session down, so every error is swallowed into errors.log.
+"""
+import json
+import os
+import socket
+import sys
+from datetime import datetime, timezone
+
+from . import config
+
+
+def run(stdin=sys.stdin):
+    cfg = config.load()
+    try:
+        hook = json.load(stdin)
+        event = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "event": hook.get("hook_event_name"),
+            "session": hook.get("session_id"),
+            "cwd": hook.get("cwd"),
+            "host": socket.gethostname(),
+            # SessionEnd sends "reason" (clear, logout, prompt_input_exit, other);
+            # SessionStart sends "source" (startup, resume, clear, compact).
+            "reason": hook.get("reason") or hook.get("source"),
+        }
+        cfg.data.mkdir(parents=True, exist_ok=True)
+        with open(cfg.events_file, "a") as f:
+            f.write(json.dumps(event) + "\n")
+    except Exception as exc:  # noqa: BLE001 - never break the user's session
+        try:
+            cfg.data.mkdir(parents=True, exist_ok=True)
+            with open(cfg.data / "errors.log", "a") as f:
+                f.write(f"{datetime.now().isoformat()} hook {exc!r}\n")
+        except OSError:
+            pass
+    return 0

sessionpulse/icons/sessionpulse-busy.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" viewBox="0 0 22 22">
+  <!-- Session Pulse mark: a prompt whose cursor became a pulse line (from the illustration kit) -->
+  <path d="M2.6 7.2 L6.4 11 L2.6 14.8" fill="none" stroke="#eeeeee" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8.4 11 H10.2 L11.6 8.6 L13.4 14.6 L15.4 5.4 L17.2 12.6 L18.2 11 H20.2" fill="none" stroke="#f0a24a" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

sessionpulse/icons/sessionpulse-idle.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" viewBox="0 0 22 22">
+  <!-- Session Pulse mark: a prompt whose cursor became a pulse line (from the illustration kit) -->
+  <path d="M2.6 7.2 L6.4 11 L2.6 14.8" fill="none" stroke="#eeeeee" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8.4 11 H10.2 L11.6 8.6 L13.4 14.6 L15.4 5.4 L17.2 12.6 L18.2 11 H20.2" fill="none" stroke="#5cc27a" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

sessionpulse/icons/sessionpulse-none.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" viewBox="0 0 22 22">
+  <!-- Session Pulse mark: a prompt whose cursor became a pulse line (from the illustration kit) -->
+  <path d="M2.6 7.2 L6.4 11 L2.6 14.8" fill="none" stroke="#eeeeee" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8.4 11 H10.2 L11.6 8.6 L13.4 14.6 L15.4 5.4 L17.2 12.6 L18.2 11 H20.2" fill="none" stroke="#8a94a0" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>