session-saloon 0.1.0__py3-none-any.whl

session_saloon/__init__.py

@@ -0,0 +1,3 @@
+"""Session Saloon: a local, live dashboard for Claude Code sessions."""
+
+__version__ = "0.1.0"

session_saloon/__main__.py

@@ -0,0 +1,103 @@
+"""Command-line entry point: ``saloon``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from . import __version__
+from .config import Config, config_path, load_config, resolve_codex_dir, resolve_projects_dir, served_path
+from .server import App, SaloonServer, open_browser, probe_existing
+from .tracker import ServedStore, Tracker
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="saloon",
+        description="A local, live dashboard that shows your Claude Code sessions as customers at a saloon bar.",
+    )
+    p.add_argument("--hours", type=float, help="time window in hours (default 72; 0 = no limit)")
+    p.add_argument("--port", type=int, help="port to serve on (default 7317)")
+    p.add_argument("--no-open", action="store_true", help="do not open the browser")
+    p.add_argument("--dump", action="store_true", help="print the snapshot as JSON and exit")
+    p.add_argument("--projects-dir", metavar="PATH", help="transcript root (default: ~/.claude/projects, or $CLAUDE_CONFIG_DIR/projects)")
+    p.add_argument("--codex-dir", metavar="PATH", help="Codex home (default: $CODEX_HOME or ~/.codex); sessions live in its sessions/ folder")
+    p.add_argument("--only", choices=["claude", "codex"], help="show only one agent's sessions")
+    p.add_argument("--demo", action="store_true", help="serve a synthetic, animated snapshot instead of real sessions")
+    p.add_argument("--config", metavar="FILE", help=f"config file (default: {config_path()})")
+    p.add_argument("--now", type=float, help=argparse.SUPPRESS)  # debugging aid: pretend it is this unix time (with --dump)
+    p.add_argument("--version", action="version", version=f"session-saloon {__version__}")
+    return p
+
+
+def config_from_args(args: argparse.Namespace) -> Config:
+    cfg = load_config(Path(args.config) if args.config else None)
+    if args.hours is not None:
+        cfg.hours = args.hours
+    if args.port is not None:
+        cfg.port = args.port
+    if args.projects_dir:
+        cfg.projects_dir = args.projects_dir
+    if args.codex_dir:
+        cfg.codex_dir = args.codex_dir
+    if args.only:
+        cfg.sources = [args.only]
+    return cfg
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    cfg = config_from_args(args)
+    if not 1 <= cfg.port <= 65535:
+        print(f"saloon: invalid port {cfg.port}", file=sys.stderr)
+        return 2
+
+    if args.dump:
+        tracker = Tracker(cfg, ServedStore(served_path()))
+        print(json.dumps(tracker.snapshot(args.now), indent=2))
+        return 0
+
+    if args.demo:
+        from .demo import make_demo
+
+        app = App(cfg, demo=make_demo(), served=ServedStore(None), persist_config=False)
+    else:
+        roots = []
+        if "claude" in cfg.sources:
+            roots.append(resolve_projects_dir(cfg))
+        if "codex" in cfg.sources:
+            roots.append(resolve_codex_dir(cfg) / "sessions")
+        if not any(r.is_dir() for r in roots):
+            where = " or ".join(str(r) for r in roots)
+            print(f"saloon: no transcripts found at {where} (use --projects-dir / --codex-dir, or start a session first)", file=sys.stderr)
+        app = App(cfg, tracker=Tracker(cfg, ServedStore(served_path())))
+
+    try:
+        server = SaloonServer(cfg.port, app)
+    except OSError:
+        if probe_existing(cfg.port):
+            print(f"Session Saloon is already open on http://127.0.0.1:{cfg.port}/")
+            if not args.no_open:
+                open_browser(cfg.port)
+            return 0
+        print(f"saloon: port {cfg.port} is in use by something else (try --port)", file=sys.stderr)
+        return 1
+
+    url = f"http://127.0.0.1:{cfg.port}/"
+    print(f"Session Saloon is open at {url}  (Ctrl+C to close the bar)")
+    if not args.no_open:
+        open_browser(cfg.port)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

session_saloon/codex.py

@@ -0,0 +1,130 @@
+"""All knowledge of the Codex CLI rollout format lives here.
+
+Codex writes ``~/.codex/sessions/YYYY/MM/DD/rollout-<time>-<uuid>.jsonl``. Each line is
+``{"timestamp", "type", "payload"}``. Unlike Claude Code, turn boundaries are explicit
+(``task_started`` / ``task_complete`` / ``turn_aborted``), so no "quiet" heuristic is needed
+to detect a finished turn. Like the Claude side, this is not a public contract: unknown
+fields and lines are ignored.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Optional, Sequence
+
+from . import transcript as tr
+
+WORK_ITEMS = {
+    "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output",
+    "local_shell_call", "web_search_call", "tool_search_call", "reasoning",
+}
+TOOL_CALLS = {"function_call", "custom_tool_call", "local_shell_call", "web_search_call", "tool_search_call"}
+HEADLESS_SOURCES = {"exec", "mcp"}  # `codex exec` and the MCP server run without a person at the keyboard
+
+
+def clean_cwd(cwd: Any) -> Optional[str]:
+    if not isinstance(cwd, str) or not cwd:
+        return None
+    return cwd[4:] if cwd.startswith("\\\\?\\") else cwd  # Windows extended-length prefix
+
+
+def parse_line(raw: str, markers: Sequence[str] = ()) -> Optional[tr.Record]:
+    raw = raw.strip()
+    if not raw:
+        return None
+    try:
+        obj = json.loads(raw)
+    except ValueError:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    return parse_object(obj)
+
+
+def parse_object(obj: Dict[str, Any]) -> tr.Record:
+    rec = tr.Record()
+    rec.ts = tr.parse_timestamp(obj.get("timestamp"))
+    payload = obj.get("payload")
+    p: Dict[str, Any] = payload if isinstance(payload, dict) else {}
+    kind = obj.get("type")
+    ptype = p.get("type")
+
+    if kind == "session_meta":
+        rec.cwd = clean_cwd(p.get("cwd"))
+        git = p.get("git")
+        if isinstance(git, dict) and isinstance(git.get("branch"), str):
+            rec.branch = git["branch"]
+        _parse_source(p, rec)
+    elif kind == "turn_context":
+        rec.cwd = clean_cwd(p.get("cwd"))
+        model = p.get("model")
+        if isinstance(model, str) and model:
+            rec.model = model
+    elif kind == "compacted":
+        rec.kind = tr.COMPACT
+    elif kind == "event_msg":
+        _parse_event(p, ptype, rec)
+    elif kind == "response_item":
+        _parse_item(p, ptype, rec)
+    return rec
+
+
+def _parse_source(p: Dict[str, Any], rec: tr.Record) -> None:
+    source = p.get("source")
+    if isinstance(source, str):
+        if source in HEADLESS_SOURCES or p.get("originator") == "codex_exec":
+            rec.headless = True
+        return
+    if isinstance(source, dict) and isinstance(source.get("subagent"), dict):
+        spawn = source["subagent"].get("thread_spawn")
+        parent = spawn.get("parent_thread_id") if isinstance(spawn, dict) else None
+        if isinstance(parent, str) and parent:
+            rec.parent = parent  # a helper thread of another session: shown as a "mate" of it
+        else:
+            rec.headless = True  # e.g. the guardian reviewer: an automation
+
+
+def _parse_event(p: Dict[str, Any], ptype: Any, rec: tr.Record) -> None:
+    if ptype == "task_started":
+        rec.kind = tr.WORK
+    elif ptype == "user_message":
+        text = p.get("message")
+        if isinstance(text, str) and text.strip():
+            rec.kind = tr.PROMPT
+            rec.text = text.strip()[: tr.PROMPT_TEXT_LIMIT]
+    elif ptype == "task_complete":
+        rec.kind = tr.END
+    elif ptype == "turn_aborted":
+        rec.kind = tr.INTERRUPT
+    elif ptype == "token_count":
+        info = p.get("info")
+        usage = info.get("total_token_usage") if isinstance(info, dict) else None
+        out = usage.get("output_tokens") if isinstance(usage, dict) else None
+        if isinstance(out, (int, float)) and not isinstance(out, bool) and out >= 0:
+            rec.out_tokens_total = int(out)
+    elif ptype == "item_completed":
+        # Interactive sessions record what the person typed as a completed UserMessage item.
+        item = p.get("item")
+        if isinstance(item, dict) and item.get("type") == "UserMessage":
+            text = _item_text(item.get("content"))
+            if text:
+                rec.kind = tr.PROMPT
+                rec.text = text[: tr.PROMPT_TEXT_LIMIT]
+    # agent_message, thread_settings_applied, other items: they trail the turn markers, so
+    # they must not flip a finished turn back to "working".
+
+
+def _item_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if not isinstance(content, list):
+        return ""
+    parts = [b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text" and isinstance(b.get("text"), str)]
+    return "\n".join(parts).strip()
+
+
+def _parse_item(p: Dict[str, Any], ptype: Any, rec: tr.Record) -> None:
+    if ptype in WORK_ITEMS or (ptype == "message" and p.get("role") == "assistant"):
+        rec.kind = tr.WORK
+        if ptype in TOOL_CALLS:
+            rec.tool_calls = 1

session_saloon/config.py

@@ -0,0 +1,277 @@
+"""Defaults, config file and command-line overrides.
+
+Every heuristic threshold lives in :class:`Config`. Precedence, lowest to
+highest: built-in defaults, config file, command-line flags.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+APP = "session-saloon"
+
+# A user line starting with one of these is not something the human typed.
+DEFAULT_PROMPT_MARKERS: List[str] = [
+    "<system-reminder",
+    "<command-name",
+    "<command-message",
+    "<command-args",
+    "<local-command",
+    "<task-notification",
+    "<agent-message",
+    "Stop hook feedback",
+    "This session is being continued",
+    "Caveat:",
+    "Base directory for this skill",
+    "## Instructions",
+    "[Image:",
+]
+
+SHELLS = ("auto", "powershell", "posix")
+
+
+@dataclass
+class Config:
+    # Window and server
+    hours: float = 72.0
+    port: int = 7317
+    projects_dir: Optional[str] = None  # Claude Code transcripts
+    codex_dir: Optional[str] = None  # Codex home (contains sessions/)
+    sources: List[str] = field(default_factory=lambda: ["claude", "codex"])
+    # State-machine thresholds, all in seconds
+    quiet_end: float = 180.0  # text-only assistant message + quiet => waiting
+    stall_after: float = 900.0  # mid-turn + quiet => stalled
+    late_after: float = 1200.0  # waiting this long => late (display mood)
+    doze_after: float = 7200.0  # waiting this long => dozing (display mood)
+    subagent_live: float = 120.0  # subagent file changed this recently => live
+    # Parsing
+    prompt_markers: List[str] = field(default_factory=lambda: list(DEFAULT_PROMPT_MARKERS))
+    # Presentation
+    shell: str = "auto"  # resume command flavour: auto | powershell | posix
+    aliases: Dict[str, str] = field(default_factory=dict)  # project name -> shown name
+
+    def public(self) -> Dict[str, Any]:
+        """The subset the page needs, and the settings panel edits."""
+        return {
+            "hours": self.hours,
+            "quietEnd": self.quiet_end,
+            "stallAfter": self.stall_after,
+            "lateAfter": self.late_after,
+            "dozeAfter": self.doze_after,
+            "subagentLive": self.subagent_live,
+            "shell": self.shell,
+            "aliases": dict(self.aliases),
+        }
+
+
+# ---------------------------------------------------------------- locations
+
+def config_dir() -> Path:
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
+        return Path(base) / APP
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / APP
+
+
+def data_dir() -> Path:
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
+        return Path(base) / APP
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / APP
+    base = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    return Path(base) / APP
+
+
+def config_path() -> Path:
+    return config_dir() / "config.toml"
+
+
+def served_path() -> Path:
+    return data_dir() / "served.json"
+
+
+def default_projects_dir() -> Path:
+    root = os.environ.get("CLAUDE_CONFIG_DIR")
+    base = Path(root).expanduser() if root else Path.home() / ".claude"
+    return base / "projects"
+
+
+def resolve_projects_dir(cfg: Config) -> Path:
+    return Path(cfg.projects_dir).expanduser() if cfg.projects_dir else default_projects_dir()
+
+
+def resolve_codex_dir(cfg: Config) -> Path:
+    if cfg.codex_dir:
+        return Path(cfg.codex_dir).expanduser()
+    root = os.environ.get("CODEX_HOME")
+    return Path(root).expanduser() if root else Path.home() / ".codex"
+
+
+def detect_shell() -> str:
+    return "powershell" if sys.platform == "win32" else "posix"
+
+
+# --------------------------------------------------------------- file format
+
+def _load_file(path: Path) -> Dict[str, Any]:
+    """Read TOML (3.11+) or, on older Pythons, JSON. Bad files are ignored."""
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    try:
+        import tomllib  # type: ignore[import-not-found]
+
+        return tomllib.loads(text)
+    except ImportError:
+        pass
+    except Exception:
+        return {}
+    try:
+        data = json.loads(text)
+        return data if isinstance(data, dict) else {}
+    except ValueError:
+        return {}
+
+
+def _apply(cfg: Config, data: Dict[str, Any]) -> None:
+    """Copy known keys from a parsed file into cfg, ignoring bad types."""
+    flat: Dict[str, Any] = {}
+    for key, value in data.items():
+        if key == "projects" and isinstance(value, dict):
+            alias = value.get("alias")
+            if isinstance(alias, dict):
+                flat["aliases"] = alias
+        elif key == "thresholds" and isinstance(value, dict):
+            flat.update(value)
+        else:
+            flat[key] = value
+    for f in fields(Config):
+        if f.name not in flat:
+            continue
+        value = flat[f.name]
+        current = getattr(cfg, f.name)
+        if isinstance(current, bool):
+            continue
+        if isinstance(current, (int, float)) and isinstance(value, (int, float)) and not isinstance(value, bool):
+            setattr(cfg, f.name, type(current)(value))
+        elif isinstance(current, str) and isinstance(value, str):
+            setattr(cfg, f.name, value)
+        elif f.name in ("projects_dir", "codex_dir") and isinstance(value, str):
+            setattr(cfg, f.name, value)
+        elif f.name == "sources" and isinstance(value, list) and all(v in ("claude", "codex") for v in value):
+            cfg.sources = list(value)
+        elif f.name == "prompt_markers" and isinstance(value, list) and all(isinstance(x, str) for x in value):
+            cfg.prompt_markers = list(value)
+        elif f.name == "aliases" and isinstance(value, dict):
+            cfg.aliases = {str(k): str(v) for k, v in value.items()}
+    if cfg.shell not in SHELLS:
+        cfg.shell = "auto"
+
+
+def load_config(path: Optional[Path] = None) -> Config:
+    cfg = Config()
+    _apply(cfg, _load_file(path or config_path()))
+    return cfg
+
+
+def _toml_str(s: str) -> str:
+    return json.dumps(s, ensure_ascii=False)  # JSON strings are valid TOML basic strings
+
+
+def dump_toml(cfg: Config) -> str:
+    """Write the user-editable part of the config as TOML (a JSON file on old Pythons)."""
+    if sys.version_info < (3, 11):
+        return json.dumps(
+            {
+                "hours": cfg.hours,
+                "thresholds": {
+                    "quiet_end": cfg.quiet_end,
+                    "stall_after": cfg.stall_after,
+                    "late_after": cfg.late_after,
+                    "doze_after": cfg.doze_after,
+                    "subagent_live": cfg.subagent_live,
+                },
+                "shell": cfg.shell,
+                "projects": {"alias": cfg.aliases},
+            },
+            indent=2,
+        )
+    lines = [
+        "# Session Saloon settings. Thresholds are in seconds.",
+        f"hours = {cfg.hours:g}",
+        f"shell = {_toml_str(cfg.shell)}",
+        "",
+        "[thresholds]",
+        f"quiet_end = {cfg.quiet_end:g}",
+        f"stall_after = {cfg.stall_after:g}",
+        f"late_after = {cfg.late_after:g}",
+        f"doze_after = {cfg.doze_after:g}",
+        f"subagent_live = {cfg.subagent_live:g}",
+        "",
+        "[projects.alias]",
+    ]
+    for k, v in cfg.aliases.items():
+        lines.append(f"{_toml_str(k)} = {_toml_str(v)}")
+    return "\n".join(lines) + "\n"
+
+
+def save_config(cfg: Config, path: Optional[Path] = None) -> None:
+    path = path or config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(dump_toml(cfg), encoding="utf-8")
+    os.replace(tmp, path)
+
+
+# ------------------------------------------------------------ settings edits
+
+_NUMERIC_LIMITS = {
+    # key: (attribute, min, max)
+    "hours": ("hours", 0, 24 * 365),  # 0 = no limit
+    "quietEnd": ("quiet_end", 10, 3600),
+    "stallAfter": ("stall_after", 60, 24 * 3600),
+    "lateAfter": ("late_after", 60, 24 * 3600),
+    "dozeAfter": ("doze_after", 300, 30 * 24 * 3600),
+    "subagentLive": ("subagent_live", 10, 3600),
+}
+
+
+def update_from_request(cfg: Config, body: Dict[str, Any]) -> List[str]:
+    """Apply a validated settings change to cfg. Returns a list of errors (empty = ok)."""
+    errors: List[str] = []
+    staged: Dict[str, Any] = {}
+    for key, (attr, lo, hi) in _NUMERIC_LIMITS.items():
+        if key not in body:
+            continue
+        v = body[key]
+        if isinstance(v, bool) or not isinstance(v, (int, float)) or not (lo <= v <= hi):
+            errors.append(f"{key} must be a number between {lo} and {hi}")
+        else:
+            staged[attr] = float(v)
+    if "shell" in body:
+        if body["shell"] in SHELLS:
+            staged["shell"] = body["shell"]
+        else:
+            errors.append("shell must be one of " + ", ".join(SHELLS))
+    if "aliases" in body:
+        a = body["aliases"]
+        if (
+            isinstance(a, dict)
+            and len(a) <= 100
+            and all(isinstance(k, str) and isinstance(v, str) and 0 < len(k) <= 200 and 0 < len(v) <= 100 for k, v in a.items())
+        ):
+            staged["aliases"] = dict(a)
+        else:
+            errors.append("aliases must map project names to display names")
+    if not errors:
+        for attr, v in staged.items():
+            setattr(cfg, attr, v)
+    return errors

session_saloon/demo.py

@@ -0,0 +1,115 @@
+"""A synthetic, animated snapshot (`saloon --demo`) that shows every state.
+
+Nothing here reads real sessions, so it is safe for screenshots and the README.
+One session cycles forever (prompt, work, finish) so the pour, mug and ROUND!
+animations can be seen without running Claude.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List
+
+from .session import local_day
+
+CYCLE = 40.0  # seconds per prompt/finish cycle
+WORK_FOR = 12.0  # seconds of "working" in each cycle
+
+MIN = 60.0
+HOUR = 3600.0
+
+
+def _session(now: float, n: int, project: str, title: str, state: str, age: float, **kw: Any) -> Dict[str, Any]:
+    prompts = kw.pop("prompts", 4)
+    sess: Dict[str, Any] = {
+        "id": f"demo-{n:04d}",
+        "agent": kw.pop("agent", "claude"),
+        "project": project,
+        "cwd": f"/home/demo/{project.lower()}",
+        "title": title,
+        "branch": kw.pop("branch", "main"),
+        "model": kw.pop("model", "claude-opus-5-5"),
+        "headless": False,
+        "state": state,
+        "age": round(age, 1),
+        "firstTs": now - age - 2 * HOUR,
+        "lastTs": now - age,
+        "prompts": prompts,
+        "promptsToday": kw.pop("promptsToday", prompts),
+        "turns": kw.pop("turns", max(prompts - 1, 0)),
+        "tools": kw.pop("tools", 24),
+        "tokens": kw.pop("tokens", 31000),
+        "tokensToday": kw.pop("tokensToday", 12000),
+        "lastPrompt": kw.pop("lastPrompt", "Please look into this and tell me what you find."),
+        "prs": kw.pop("prs", []),
+        "compactions": kw.pop("compactions", 0),
+        "subagents": kw.pop("subagents", 0),
+        "subagentsLive": kw.pop("subagentsLive", 0),
+        "served": None,
+        "lastPromptTs": now - age,
+    }
+    sess.update(kw)
+    return sess
+
+
+def _pr(n: int) -> Dict[str, Any]:
+    return {"n": n, "url": f"https://example.invalid/demo/pull/{n}", "repo": "demo/repo"}
+
+
+def snapshot(now: float, t0: float) -> Dict[str, Any]:
+    elapsed = max(0.0, now - t0)
+    cycle, phase = int(elapsed // CYCLE), elapsed % CYCLE
+    working = phase < WORK_FOR
+
+    cycler = _session(
+        now, 1, "Orchard", "Refactor the checkout flow", "working" if working else "waiting",
+        phase if working else phase - WORK_FOR,
+        model="claude-opus-5-5", branch="feature/checkout", prompts=6 + cycle + 1, turns=6 + cycle + (0 if working else 1),
+        tools=40 + cycle * 9 + (int(phase * 0.7) if working else 8), tokens=52000 + cycle * 900 + int(phase * 60),
+        tokensToday=20000 + cycle * 900, prs=[_pr(101)], subagents=2, subagentsLive=2 if working else 0,
+        lastPrompt="Split the payment step into its own component and keep the tests green.",
+    )
+    cycler["lastPromptTs"] = now - phase  # the prompt that started this cycle
+
+    sessions: List[Dict[str, Any]] = [
+        cycler,
+        _session(now, 2, "Orchard", "Fix flaky invoice test", "waiting", 25 * MIN + elapsed, model="claude-sonnet-5",
+                 branch="fix/invoice-flake", prs=[_pr(98), _pr(99)], prompts=9, turns=9, tools=71, tokens=88000,
+                 lastPrompt="Run it ten times in a loop and tell me if it still fails."),
+        _session(now, 3, "Orchard", "Plan the database migration", "waiting", 8 * MIN + elapsed, model="claude-fable-5-1",
+                 branch="chore/migration", subagents=3, subagentsLive=1, prompts=3, turns=3, tools=18, tokens=19000,
+                 lastPrompt="Draft the plan first, no changes yet."),
+        _session(now, 4, "Orchard", "Old spike: caching layer", "waiting", 3 * HOUR + elapsed, model="claude-haiku-4-5",
+                 prompts=2, turns=2, tools=6, tokens=4200),
+        _session(now, 5, "Orchard", "Release notes draft", "waiting", 30 * HOUR + elapsed, model="claude-opus-5-5",
+                 prompts=5, turns=5, tools=12, tokens=15000, promptsToday=0, tokensToday=0, compactions=1),
+        _session(now, 6, "Orchard", "Upgrade the linter", "stalled", 22 * MIN + elapsed, model="claude-sonnet-5",
+                 branch="chore/lint", prompts=2, turns=1, tools=9, tokens=6100),
+        _session(now, 7, "Website", "Landing page copy", "waiting", 3 * MIN + elapsed, model="claude-haiku-4-5",
+                 branch="content/landing", prompts=4, turns=4, tools=10, tokens=8800),
+        _session(now, 8, "Website", "Fix the mobile menu", "working", 4 + (elapsed % 6), model="claude-sonnet-5",
+                 branch="fix/menu", prompts=2, turns=1, tools=14 + int(elapsed / 2) % 40, tokens=7300,
+                 subagents=1, subagentsLive=1),
+        _session(now, 9, "Website", "Accessibility audit", "waiting", 50 * MIN + elapsed, model="",
+                 prompts=3, turns=3, tools=33, tokens=27000, prs=[_pr(12), _pr(13), _pr(14)]),
+        _session(now, 14, "Orchard", "Port the importer to async", "waiting", 14 * MIN + elapsed, model="gpt-5.6-sol", agent="codex",
+                 branch="feature/async-import", prompts=5, turns=5, tools=48, tokens=41000, subagents=2, subagentsLive=1,
+                 lastPrompt="Port the importer to asyncio and keep the CLI flags the same."),
+        _session(now, 15, "Website", "Compress the hero images", "working", 6 + (elapsed % 8), model="gpt-6-astra", agent="codex",
+                 branch="perf/images", prompts=2, turns=1, tools=9 + int(elapsed / 3) % 30, tokens=6200),
+        _session(now, 10, "home", "Tidy the dotfiles", "waiting", 5 * MIN + elapsed, model="claude-opus-5-5",
+                 branch="", prompts=2, turns=2, tools=5, tokens=2400),
+        _session(now, 11, "home", "Session Saloon demo", "working", 2 + (elapsed % 5), model="claude-opus-5-5",
+                 branch="", prompts=1, turns=0, tools=3 + int(elapsed / 3) % 30, tokens=1900),
+        _session(now, 12, "automations", "nightly-triage (headless)", "working", 20 + (elapsed % 30), model="claude-haiku-4-5",
+                 headless=True, prompts=0, turns=0, tools=8 + int(elapsed / 4) % 20, tokens=3000, promptsToday=0),
+        _session(now, 13, "automations", "changelog-bot (headless)", "done", 2 * HOUR, model="claude-sonnet-5",
+                 headless=True, prompts=1, turns=1, tools=17, tokens=23000, subagents=1),
+    ]
+    sessions.sort(key=lambda d: d["lastTs"], reverse=True)
+    return {"now": now, "hours": 72, "today": local_day(now), "sessions": sessions}
+
+
+def make_demo():
+    t0 = time.time()
+    return lambda now: snapshot(now, t0)