hum-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{hum_cli-0.1.1 → hum_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hum-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: An agent harness built as an RL environment that humans can drive: session trees, interchangeable human/policy drivers, counterfactual shadow, earned autonomy, verifier in the loop.
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27

{hum_cli-0.1.1 → hum_cli-0.1.2}/hum/__init__.py

@@ -1,4 +1,4 @@
 """Hum — an agent harness built as an RL environment that humans can drive.
 
 हम (Hindi): we, us. Human and model, one harness."""
-__version__ = "0.1.1"
+__version__ = "0.1.2"

hum_cli-0.1.2/hum/catalog.py

@@ -0,0 +1,64 @@
+"""What a person sees when they choose a session to pick up: when, what, how far,
+what it cost, where. Local files first; the server's list fills in sessions from
+other machines (pulled on demand when chosen)."""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from hum.runtime.store import list_sessions
+
+
+def _summary(path: Path) -> dict[str, Any]:
+    steps = 0
+    cost = 0.0
+    task: dict[str, Any] = {}
+    last = 0.0
+    try:
+        with path.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                k = r.get("kind")
+                if k == "session":
+                    task = r.get("task") or {}
+                elif k == "meta":
+                    task.update({kk: v for kk, v in r.items() if kk != "kind"})
+                elif k == "node":
+                    if r.get("branch") == "main":
+                        steps += 1
+                    u = (r.get("turn") or {}).get("usage") or {}
+                    cost += float(u.get("cost_usd") or 0)
+                    last = max(last, float(r.get("at") or 0))
+    except OSError:
+        pass
+    return {"name": path.name, "instruction": (task.get("instruction") or "")[:200], "cwd": task.get("cwd"), "model": task.get("model"),
+            "steps": steps, "cost_usd": round(cost, 4), "at": last or path.stat().st_mtime, "local": True}
+
+
+def catalog(remote: list[dict[str, Any]] | None = None) -> list[dict[str, Any]]:
+    """Newest first. Remote entries not present locally are included with local=False."""
+    items = {p.name: _summary(p) for p in list_sessions()}
+    for r in remote or []:
+        n = r.get("name")
+        if n and n not in items:
+            items[n] = {"name": n, "instruction": (r.get("instruction") or "")[:200], "cwd": r.get("cwd"), "model": r.get("model"),
+                        "steps": None, "cost_usd": None, "at": float(r.get("created") or 0), "local": False}
+    return sorted(items.values(), key=lambda x: x["at"], reverse=True)
+
+
+def when(at: float, now: float | None = None) -> str:
+    d = (now or time.time()) - at
+    if d < 90:
+        return "just now"
+    if d < 3600:
+        return f"{int(d // 60)}m ago"
+    if d < 86400:
+        return f"{int(d // 3600)}h ago"
+    if d < 7 * 86400:
+        return f"{int(d // 86400)}d ago"
+    return time.strftime("%b %d", time.localtime(at))

{hum_cli-0.1.1 → hum_cli-0.1.2}/hum/cli.py

@@ -37,6 +37,7 @@ HELP = """/help          this
 /model [name]  show or switch the model for this session
 /tools         what's mounted
 /cost          tokens and cost so far
+/compact       summarise and restart the context now
 /quit          leave (Ctrl-D works too)
 !cmd           run a command yourself
 Ctrl-C         stop the current turn"""
@@ -336,6 +337,10 @@ class Client:
                 self.ui.info(f"model: {self.cfg.model}" + (f" via {self.cfg.api_base}" if self.cfg.api_base else ""))
         elif cmd == "tools":
             self.ui.info(", ".join(sorted(self.tools.tools)))
+        elif cmd == "compact":
+            head = session.head("main")
+            cid = asyncio.get_event_loop().run_until_complete(runner._compact(head.id if head else None, runner.policy, 0)) if False else None
+            self.ui.info("use /compact from the terminal UI; the plain client compacts automatically at the threshold")
         elif cmd == "cost":
             u = runner.usage + getattr(getattr(self, "delegation", None), "usage", u.__class__())
             self.ui.info(f"{u.input_tokens}+{u.output_tokens} tokens · ${u.cost_usd:.4f} · {runner.turns} turns" +
@@ -354,20 +359,20 @@ class Client:
 # --- commands -------------------------------------------------------------------------------------
 
 def cmd_sessions(ui: UI) -> None:
-    for p in list_sessions():
-        try:
-            s = Session.load(p)
-            hv = sum(1 for n in s.nodes.values() if n.intervention)
-            ui.console.print(f"[dim]{p.stem}[/]  {len(s.order):>3} turns  {hv:>2} yours  {s.task.get('instruction', '')[:70]}")
-        except Exception as e:  # noqa: BLE001
-            ui.console.print(f"[dim]{p.name}[/]  (unreadable: {e})")
+    from hum import sync
+    from hum.catalog import catalog, when
+    for it in catalog(sync.remote_list()):
+        steps = f"{it['steps']:>3} steps" if it["steps"] is not None else "  (on the server)"
+        cost = f"${it['cost_usd']:.2f}" if it["cost_usd"] else ""
+        ui.console.print(f"[dim]{when(it['at']):>9}[/]  {steps:<16} {cost:>6}  {it['instruction'][:60]}  [dim]{Path(it['cwd']).name if it.get('cwd') else ''}[/]")
 
 
 def _find(name: str) -> Path:
-    ms = [p for p in list_sessions() if name in p.name] if name and name != "last" else list_sessions()
-    if not ms:
+    from hum.engine import find_session
+    p = find_session(name or "last")
+    if p is None:
         sys.exit(f"no session matching {name!r}")
-    return ms[-1]
+    return p
 
 
 def cmd_show(ui: UI, name: str) -> None:
@@ -494,6 +499,7 @@ def main(argv: list[str] | None = None) -> int:
     cp = sub.add_parser("chat"); cp.add_argument("task", nargs="?"); cp.add_argument("-C", "--cwd", default="."); cp.add_argument("--plain", action="store_true", help="the Rich client, no Ink")
     rp = sub.add_parser("run"); rp.add_argument("task"); rp.add_argument("-C", "--cwd", default=".")
     rs = sub.add_parser("resume"); rs.add_argument("name", nargs="?", default="last"); rs.add_argument("--plain", action="store_true")
+    rs.add_argument("--last", dest="pick_last", action="store_true", help="skip the picker; continue the newest session")
     lg = sub.add_parser("login"); lg.add_argument("--auth-url")
     sub.add_parser("logout"); sub.add_parser("whoami"); sub.add_parser("sessions"); sub.add_parser("sync")
     mp = sub.add_parser("model"); mp.add_argument("name", nargs="?")
@@ -533,13 +539,12 @@ def main(argv: list[str] | None = None) -> int:
         if a.cmd == "run":
             return asyncio.run(Client(cfg, Path(a.cwd).resolve(), ui).one_shot(a.task))
         if a.cmd == "resume":
-            s = Session.load(_find(a.name))
-            cwd = Path(s.task.get("cwd", ".")).resolve()
             if not a.plain and sys.stdin.isatty():
-                rc = launch_tui(cfg, cwd, None, a.name)
+                rc = launch_tui(cfg, Path(a.cwd if hasattr(a, "cwd") else ".").resolve(), None, "pick" if a.name == "last" and not a.pick_last else a.name)
                 if rc >= 0:
                     return rc
-            return asyncio.run(Client(cfg, cwd, ui).chat(None, resume=s))
+            s = Session.load(_find(a.name))
+            return asyncio.run(Client(cfg, Path(s.task.get("cwd", ".")).resolve(), ui).chat(None, resume=s))
         if not a.plain and sys.stdin.isatty():
             rc = launch_tui(cfg, Path(a.cwd).resolve(), a.task, None)
             if rc >= 0:

{hum_cli-0.1.1 → hum_cli-0.1.2}/hum/engine.py

@@ -8,7 +8,9 @@ other way round (the front-end was spawned by Python and told where to connect).
 
 Front-end → engine (commands)
   {"cmd": "start", "task": "…"}             begin a session with this instruction
-  {"cmd": "resume", "name": "…"}            re-open a saved session (name or "last")
+  {"cmd": "resume", "name": "…"}            re-open a saved session (name or "last"); while idle, switches sessions
+  {"cmd": "sessions"}                        list sessions to pick from (local and on the server) → sessions {items}
+  {"cmd": "compact"}                         summarise and restart the context now (while idle)
   {"cmd": "message", "text": "…"}           steer (while busy) or a follow-up (while idle)
   {"cmd": "shell", "command": "…"}          the person runs a command themselves (!cmd)
   {"cmd": "interrupt"}                      stop the current turn; what it had so far is kept
@@ -22,7 +24,7 @@ Engine → front-end (events); every event has "type"
   human_edit {stat}                            compaction {prompt_tokens_before}
   turn_end {turns, cost_usd, input_tokens, output_tokens, elapsed_s, stop_reason}
   interrupted {kept}                           info {text} · warn {text} · error {text}
-  session {name, path}                         idle · busy {phase} · retry {attempt, text} · bye
+  session {name, path}                         idle · busy {phase} · retry {attempt, text} · bye · sessions {items}
 """
 from __future__ import annotations
 
@@ -38,7 +40,7 @@ from hum.cli import Client, Uploader, make_llm
 from hum.runtime import CURRENT_AGENT, HumanAction, HumanDriver, PolicyDriver, Session, StreamEvents, ToolCall, ToolRegistry, Turn
 from hum.runtime.config import Config
 from hum.runtime.llm import describe_partial_call, error_text
-from hum.runtime.store import list_sessions
+from hum.runtime.store import home, list_sessions
 from hum.ui import UI
 
 
@@ -200,15 +202,44 @@ class Engine:
                 self._open(self.client._session(str(cmd.get("task", "")).strip(), "chat"))
                 self._launch(None, None)
         elif kind == "resume":
-            if self.session is None:
-                name = str(cmd.get("name") or "last")
-                ms = [p for p in list_sessions() if name in p.name] if name != "last" else list_sessions()
-                if not ms:
-                    self.wire.send("error", text=f"no session matching {name!r}")
-                    return
-                s = Session.load(ms[-1])
-                self._open(s)
-                self.wire.send("idle")
+            if self.busy:
+                self.wire.send("warn", text="finish or stop the current turn first")
+                return
+            name = str(cmd.get("name") or "last")
+            path = await asyncio.to_thread(find_session, name)
+            if path is None:
+                self.wire.send("error", text=f"no session matching {name!r}")
+                return
+            if self.session is not None:
+                if self.uploader:
+                    await self.uploader.stop()
+                await self.client.close()
+            s = Session.load(path)
+            cwd = Path(s.task.get("cwd") or self.cwd).resolve()
+            if cwd != self.cwd:
+                # the session belongs to another directory: work there
+                self.cwd = cwd
+                self.client = Client(self.cfg, cwd, self.ui)
+                await self.client.mount()
+            self._open(s)
+            self.wire.send("idle")
+        elif kind == "sessions":
+            from hum import sync
+            from hum.catalog import catalog, when
+            remote = await asyncio.to_thread(sync.remote_list)
+            items = catalog(remote)
+            for it in items:
+                it["when"] = when(it["at"])
+            self.wire.send("sessions", items=items[:50])
+        elif kind == "compact":
+            if self.busy or self.runner is None or self.session is None:
+                self.wire.send("warn", text="nothing to compact yet" if self.session is None else "wait for the current turn to finish")
+                return
+            head = self.session.head("main")
+            self.wire.send("busy", phase="compacting")
+            cid = await self.runner._compact(head.id if head else None, self.runner.policy, 0)
+            self.wire.send("info", text="context summarised and restarted" if cid else "compaction failed; context unchanged")
+            self.wire.send("idle")
         elif kind == "message":
             text = str(cmd.get("text", "")).strip()
             if not text:
@@ -301,6 +332,18 @@ class Engine:
             pass
 
 
+def find_session(name: str) -> Path | None:
+    """A local session by name (substring; "last" = newest), else pull it from the server."""
+    from hum import sync
+    ms = [p for p in list_sessions() if name in p.name] if name != "last" else list_sessions()
+    if ms:
+        return ms[-1]
+    for r in sync.remote_list():
+        if name == "last" or name in r.get("name", ""):
+            return sync.pull(r["name"])
+    return None
+
+
 async def serve(cfg: Config, cwd: Path, *, listen: bool, port: int | None) -> int:
     """``listen``: bind an ephemeral localhost port, print it, accept one front-end.
     Otherwise connect to ``port`` (the front-end is listening)."""

{hum_cli-0.1.1 → hum_cli-0.1.2}/hum/sync.py

@@ -54,3 +54,38 @@ def sync_all(client: Any = None) -> tuple[int, int]:
         if upload(p, c, client=client):
             sent += 1
     return sent, skipped
+
+
+def remote_list(creds: Credentials | None = None, client: Any = None, timeout: float = 8.0) -> list[dict[str, Any]]:
+    """Sessions the server holds for this person (any machine). Empty on any failure."""
+    import httpx
+
+    c = creds or load_creds()
+    if not c.logged_in:
+        return []
+    try:
+        http = client or httpx.Client(timeout=timeout)
+        r = http.get(f"{c.auth_url}/sessions", headers={"Authorization": f"Bearer {c.access_token}"})
+        return list(r.json()) if r.status_code == 200 else []
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def pull(name: str, creds: Credentials | None = None, client: Any = None, timeout: float = 30.0) -> Path | None:
+    """Fetch one session file from the server into ~/.hum/sessions (so it can be resumed here)."""
+    import httpx
+
+    c = creds or load_creds()
+    if not c.logged_in:
+        return None
+    try:
+        http = client or httpx.Client(timeout=timeout)
+        r = http.get(f"{c.auth_url}/sessions/{name}", headers={"Authorization": f"Bearer {c.access_token}"})
+        if r.status_code != 200 or not r.content:
+            return None
+        dest = home() / "sessions" / Path(name).name
+        dest.write_bytes(r.content)
+        _mark(dest.name, {"size": dest.stat().st_size, "id": None})
+        return dest
+    except Exception:  # noqa: BLE001
+        return None

{hum_cli-0.1.1 → hum_cli-0.1.2}/hum/tui/cli.mjs

@@ -83713,13 +83713,15 @@ var tail = (s, n) => {
   return l.length <= n ? s : "\u2026\n" + l.slice(-n).join("\n");
 };
 var COMMANDS = [
+  { name: "/resume", desc: "pick a past session to continue (this machine or any other)" },
+  { name: "/compact", desc: "summarise and restart the context now" },
   { name: "/model", desc: "switch the model for this session (/model <name>)" },
   { name: "/cost", desc: "tokens and cost so far" },
   { name: "/tools", desc: "what is mounted" },
   { name: "/help", desc: "keys and commands" },
   { name: "/quit", desc: "save and leave" }
 ];
-var HELP = "!cmd runs a command as you \xB7 esc interrupts the model (what it had is kept) \xB7 type while it works to steer \xB7 edit files in your editor any time (recorded as your turn) \xB7 ctrl+c twice quits";
+var HELP = "!cmd runs a command as you \xB7 esc interrupts the model (what it had is kept) \xB7 type while it works to steer \xB7 edit files in your editor any time (recorded as your turn) \xB7 /resume picks a past session \xB7 /compact restarts the context from a summary \xB7 ctrl+c twice quits";
 function App2({ engine: engine2, task, resume }) {
   const { exit } = use_app_default();
   const { stdout } = use_stdout_default();
@@ -83736,6 +83738,7 @@ function App2({ engine: engine2, task, resume }) {
   const [menuIndex, setMenuIndex] = (0, import_react24.useState)(0);
   const [elapsed, setElapsed] = (0, import_react24.useState)(0);
   const [ctrlc, setCtrlc] = (0, import_react24.useState)(0);
+  const [picker, setPicker] = (0, import_react24.useState)(null);
   const nextId = (0, import_react24.useRef)(0);
   const phaseRef = (0, import_react24.useRef)("connecting");
   const turnT0 = (0, import_react24.useRef)(null);
@@ -83813,12 +83816,24 @@ function App2({ engine: engine2, task, resume }) {
         modelRef.current = ev.model;
         append({ kind: "banner", text: `${ev.model}${ev.user ? ` \xB7 ${ev.user}` : ""} \xB7 ${ev.cwd} \xB7 tools: ${ev.tools.join(", ")}` });
         if (task) engine2.send({ cmd: "start", task });
-        else if (resume) engine2.send({ cmd: "resume", name: resume });
+        else if (resume === "pick") {
+          setPhaseBoth("idle");
+          engine2.send({ cmd: "sessions" });
+        } else if (resume) engine2.send({ cmd: "resume", name: resume });
         else setPhaseBoth("idle");
         break;
+      case "sessions":
+        if (!ev.items || ev.items.length === 0) {
+          append({ kind: "info", text: "no sessions yet" });
+          break;
+        }
+        setPicker({ items: ev.items.slice(0, 12), index: 0 });
+        break;
       case "session":
         setSession(ev.name);
+        setSpend(0);
         if (ev.model) modelRef.current = ev.model;
+        append({ kind: "info", text: `session ${ev.name}` });
         break;
       case "turn_start":
         turnT0.current = turnT0.current || Date.now();
@@ -83937,6 +83952,16 @@ function App2({ engine: engine2, task, resume }) {
       quit();
       return;
     }
+    if (picker) {
+      if (key.upArrow) setPicker((p) => ({ ...p, index: (p.index + p.items.length - 1) % p.items.length }));
+      else if (key.downArrow || key.tab) setPicker((p) => ({ ...p, index: (p.index + 1) % p.items.length }));
+      else if (key.return) {
+        const it = picker.items[picker.index];
+        setPicker(null);
+        engine2.send({ cmd: "resume", name: it.name });
+      } else if (key.escape) setPicker(null);
+      return;
+    }
     if (menu.length > 0) {
       if (key.upArrow) setMenuIndex((i) => (i + menu.length - 1) % menu.length);
       else if (key.downArrow) setMenuIndex((i) => (i + 1) % menu.length);
@@ -83963,6 +83988,12 @@ function App2({ engine: engine2, task, resume }) {
       case "/help":
         append({ kind: "info", text: HELP });
         break;
+      case "/resume":
+        engine2.send({ cmd: "sessions" });
+        break;
+      case "/compact":
+        engine2.send({ cmd: "compact" });
+        break;
       case "/model":
         if (arg) {
           modelRef.current = arg;
@@ -84087,6 +84118,22 @@ function App2({ engine: engine2, task, resume }) {
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: ACCENT, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(build_default, { type: "dots" }) }),
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: spinnerLabel })
     ] }),
+    picker && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { children: [
+        "pick a session to continue ",
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "\xB7 enter continues \xB7 esc cancels" })
+      ] }),
+      picker.items.map((it, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "cyan", inverse: i === picker.index, children: (i === picker.index ? "\u276F " : "  ") + (it.when || "").padEnd(9) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { dimColor: i !== picker.index, children: [
+          "  ",
+          (it.instruction || "(untitled)").slice(0, Math.max(20, width - 40)),
+          it.steps != null ? `  \xB7 ${it.steps} steps` : "  \xB7 on the server",
+          it.cost_usd ? ` \xB7 ${fmtCost(it.cost_usd)}` : "",
+          it.cwd ? ` \xB7 ${path.basename(it.cwd)}` : ""
+        ] })
+      ] }, it.name))
+    ] }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "cyan", children: "\u276F " }),
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
@@ -84095,7 +84142,7 @@ function App2({ engine: engine2, task, resume }) {
           value,
           onChange: setValue,
           onSubmit,
-          focus: phase !== "dead",
+          focus: phase !== "dead" && !picker,
           navActive: menu.length === 0,
           history: historyRef.current,
           placeholder: phase === "busy" ? "type to steer \xB7 esc to stop \xB7 !cmd runs a command" : session ? "what next?" : "what are we doing?"
@@ -84221,7 +84268,7 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const x = argv[i];
     if (x === "resume") {
-      a.resume = argv[i + 1] && !argv[i + 1].startsWith("-") ? argv[++i] : "last";
+      a.resume = argv[i + 1] && !argv[i + 1].startsWith("-") ? argv[++i] : "pick";
     } else if ((x === "-C" || x === "--cwd") && argv[i + 1]) {
       a.cwd = argv[++i];
     } else if (x === "-h" || x === "--help") {

{hum_cli-0.1.1 → hum_cli-0.1.2}/npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaphi/hum",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Hum — हम. Human and model, one harness. A coding agent for your terminal.",
   "license": "UNLICENSED",
   "type": "module",

{hum_cli-0.1.1 → hum_cli-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hum-cli"
-version = "0.1.1"
+version = "0.1.2"
 description = "An agent harness built as an RL environment that humans can drive: session trees, interchangeable human/policy drivers, counterfactual shadow, earned autonomy, verifier in the loop."
 requires-python = ">=3.12"
 dependencies = ["pydantic>=2", "litellm>=1.70", "mcp>=1.2", "rich>=13", "prompt_toolkit>=3.0", "httpx>=0.27"]

{hum_cli-0.1.1 → hum_cli-0.1.2}/server/app.py

@@ -3,7 +3,7 @@
   sign-in      POST /device/code · GET /device (Firebase sign-in page) · POST /device/approve · POST /device/token
   identity     GET /me
   model proxy  POST /v1/chat/completions   (OpenAI-compatible; bearer = the person's Hum token)
-  sessions     POST /sessions              (NDJSON body → $HUM_DATA_DIR/sessions/<email>/)
+  sessions     POST /sessions · GET /sessions · GET /sessions/<name>   (NDJSON files under $HUM_DATA_DIR/sessions/<email>/)
   tool servers /mcp/<name>                 (streamable-HTTP MCP, proxied upstream; bearer = the person's Hum token)
   admin        POST /admin/invites · GET /admin/users · GET /admin/usage   (X-Admin-Key)
 
@@ -64,7 +64,7 @@ if os.environ.get("HUM_ROUTES_JSON"):
 # A header value starting with "$" names an environment variable.
 MCPS: dict[str, dict[str, Any]] = json.loads(os.environ["HUM_MCP_JSON"]) if os.environ.get("HUM_MCP_JSON") else {}
 
-app = FastAPI(title="hum", version="0.1.1")
+app = FastAPI(title="hum", version="0.1.2")
 
 
 # --- storage ------------------------------------------------------------------------
@@ -493,6 +493,35 @@ async def upload_session(request: Request, user: sqlite3.Row = Depends(bearer),
     return {"id": sid, "bytes": len(body)}
 
 
+@app.get("/sessions")
+def list_sessions(user: sqlite3.Row = Depends(bearer)) -> list[dict[str, Any]]:
+    """This person's sessions on the server, newest last: enough to pick one to resume from another machine."""
+    c = db()
+    rows = c.execute("select filename, size, created from sessions where email=? order by filename", (user["email"],)).fetchall()
+    out = []
+    for r in rows:
+        path = DATA / "sessions" / user["email"] / r["filename"]
+        meta: dict[str, Any] = {}
+        try:
+            with path.open(encoding="utf-8") as f:
+                first = json.loads(f.readline() or "{}")
+            t = first.get("task") or {}
+            meta = {"instruction": (t.get("instruction") or "")[:200], "cwd": t.get("cwd"), "model": t.get("model")}
+        except Exception:  # noqa: BLE001
+            pass
+        out.append({"name": r["filename"], "size": r["size"], "created": r["created"], **meta})
+    return out
+
+
+@app.get("/sessions/{name}")
+def get_session(name: str, user: sqlite3.Row = Depends(bearer)) -> Any:
+    from fastapi.responses import Response
+    path = DATA / "sessions" / user["email"] / Path(name).name
+    if not path.is_file():
+        raise HTTPException(404, "no such session")
+    return Response(path.read_bytes(), media_type="application/x-ndjson")
+
+
 class InviteIn(BaseModel):
     email: str
     budget_usd: float | None = None

{hum_cli-0.1.1 → hum_cli-0.1.2}/tests/test_sme_ready.py

@@ -2,6 +2,7 @@
 node, the interrupted generation, a compacted context, streamed thinking and
 tool calls, and tool servers reached through the home server."""
 import json
+import time
 from pathlib import Path
 
 import httpx
@@ -389,3 +390,91 @@ def test_explore_agents_cannot_edit_and_delegate_cannot_nest():
     assert set(d._child_tools("explore").tools) == {"read_file", "grep", "glob", "bash"}
     assert "delegate" not in d._child_tools("general").tools and "write_file" in d._child_tools("general").tools
     assert reg.tools["delegate"].concurrent and reg.tools["delegate"].mutating
+
+
+def test_catalog_lists_local_and_server_sessions(tmp_path, monkeypatch):
+    home = _cfg(tmp_path, monkeypatch)
+    from hum.catalog import catalog, when
+    from hum.runtime.models import Node
+    s = Session({"instruction": "build the posting batch", "cwd": "/w/ccpay", "model": "glm-5.3"}, path=home / "sessions" / "20260822-010000-chat.jsonl")
+    s.append(Node(turn=Turn(author="policy", content="x", usage=Usage(cost_usd=0.02))))
+    items = catalog([{"name": "20260821-000000-chat.jsonl", "instruction": "from the desktop", "created": 1.0},
+                     {"name": "20260822-010000-chat.jsonl", "instruction": "dup of local", "created": 2.0}])
+    assert [i["name"] for i in items] == ["20260822-010000-chat.jsonl", "20260821-000000-chat.jsonl"]
+    assert items[0]["local"] and items[0]["steps"] == 1 and items[0]["cost_usd"] == 0.02 and items[0]["instruction"].startswith("build")
+    assert not items[1]["local"] and items[1]["steps"] is None
+    assert when(time.time() - 30) == "just now" and when(time.time() - 7200) == "2h ago"
+
+
+def test_server_lists_and_serves_a_persons_sessions(srv):
+    S, client = srv
+    tok = _token(S, client)["access_token"]
+    body = b'{"kind": "session", "id": "s1", "task": {"instruction": "fix the reject file", "cwd": "/w"}}\n{"kind": "node", "id": "n1", "branch": "main", "turn": {"author": "policy"}}\n'
+    assert client.post("/sessions", content=body, headers={"Authorization": f"Bearer {tok}", "X-Hum-Session": "20260822-x.jsonl"}).status_code == 201
+    lst = client.get("/sessions", headers={"Authorization": f"Bearer {tok}"}).json()
+    assert [x["name"] for x in lst] == ["20260822-x.jsonl"] and lst[0]["instruction"] == "fix the reject file" and lst[0]["cwd"] == "/w"
+    r = client.get("/sessions/20260822-x.jsonl", headers={"Authorization": f"Bearer {tok}"})
+    assert r.status_code == 200 and r.content == body
+    assert client.get("/sessions/nope.jsonl", headers={"Authorization": f"Bearer {tok}"}).status_code == 404
+    assert client.get("/sessions").status_code == 401
+
+
+def test_resume_pulls_from_the_server_when_not_local(tmp_path, monkeypatch):
+    home = _cfg(tmp_path, monkeypatch)
+    (home / "credentials.json").write_text(json.dumps({"auth_url": "https://auth.test", "access_token": "tok", "email": "e@x.com"}))
+    body = b'{"kind": "session", "id": "s9", "task": {"instruction": "remote one", "cwd": "/elsewhere"}}\n'
+
+    def h(request):
+        if request.url.path == "/sessions":
+            return httpx.Response(200, json=[{"name": "20260820-remote.jsonl", "instruction": "remote one", "created": 5.0}])
+        if request.url.path == "/sessions/20260820-remote.jsonl":
+            return httpx.Response(200, content=body)
+        return httpx.Response(404)
+    from hum import sync
+    c = httpx.Client(transport=httpx.MockTransport(h))
+    real_list, real_pull = sync.remote_list, sync.pull
+    monkeypatch.setattr(sync, "remote_list", lambda creds=None, client=None, timeout=8.0: real_list(creds, c, timeout))
+    monkeypatch.setattr(sync, "pull", lambda name, creds=None, client=None, timeout=30.0: real_pull(name, None, c, timeout))
+    from hum.engine import find_session
+    p = find_session("remote")
+    assert p is not None and p.name == "20260820-remote.jsonl" and p.read_bytes() == body and p.parent == home / "sessions"
+    assert Session.load(p).task["instruction"] == "remote one"
+
+
+async def test_engine_sessions_resume_switch_and_compact(tmp_path, monkeypatch):
+    import asyncio
+    from hum import engine as E
+    home = _cfg(tmp_path, monkeypatch)
+    ws = tmp_path / "ws"; ws.mkdir()
+    monkeypatch.setattr("hum.sync.remote_list", lambda *a, **k: [])
+    llm = ScriptedLLM([
+        Turn(author="policy", content="first done", done=True, usage=Usage(input_tokens=10)),
+        Turn(author="policy", content="HANDOFF: nothing yet"),          # /compact summary
+        Turn(author="policy", content="second done", done=True),
+    ])
+    monkeypatch.setattr(cli, "make_llm", lambda cfg: llm)
+    from hum.runtime.config import load
+    cfg = load()
+    server = await asyncio.start_server(lambda r, w: E.Engine(cfg, ws, E.Wire(r, w)).serve(), "127.0.0.1", 0)
+    r, w = await asyncio.open_connection("127.0.0.1", server.sockets[0].getsockname()[1])
+    async def recv():
+        return json.loads(await r.readline())
+    async def until(t):
+        while (e := await recv())["type"] != t:
+            pass
+        return e
+    def send(**cmd):
+        w.write((json.dumps(cmd) + "\n").encode())
+    await until("hello")
+    send(cmd="start", task="session A"); await until("turn_end")
+    send(cmd="compact"); e = await until("info"); assert "summarised" in e["text"]
+    s = Session.load(next((home / "sessions").glob("*.jsonl")))
+    assert s.head("main").turn.author == "system" and s.head("main").extra["event"] == "compaction"
+    # a second session exists on disk: the picker lists both, newest first; resume switches to it
+    s2 = Session({"instruction": "session B", "cwd": str(ws)}, path=home / "sessions" / "20260822-020000-chat.jsonl")
+    send(cmd="sessions"); e = await until("sessions")
+    assert [i["instruction"] for i in e["items"]] == ["session B", "session A"] and e["items"][0]["when"] == "just now"
+    send(cmd="resume", name="020000"); e = await until("session"); assert e["name"] == "20260822-020000-chat.jsonl"
+    send(cmd="message", text="go"); await until("turn_end")
+    assert Session.load(home / "sessions" / "20260822-020000-chat.jsonl").head("main").turn.content == "second done"
+    send(cmd="quit"); await until("bye"); server.close(); await server.wait_closed()

{hum_cli-0.1.1 → hum_cli-0.1.2}/tui/src/app.jsx

@@ -36,6 +36,8 @@ const DRAFT_TAIL_LINES = 14;
 const tail = (s, n) => { const l = s.split('\n'); return l.length <= n ? s : '…\n' + l.slice(-n).join('\n'); };
 
 const COMMANDS = [
+  { name: '/resume', desc: 'pick a past session to continue (this machine or any other)' },
+  { name: '/compact', desc: 'summarise and restart the context now' },
   { name: '/model', desc: 'switch the model for this session (/model <name>)' },
   { name: '/cost', desc: 'tokens and cost so far' },
   { name: '/tools', desc: 'what is mounted' },
@@ -44,7 +46,7 @@ const COMMANDS = [
 ];
 
 const HELP = '!cmd runs a command as you · esc interrupts the model (what it had is kept) · type while it works to steer · ' +
-  'edit files in your editor any time (recorded as your turn) · ctrl+c twice quits';
+  'edit files in your editor any time (recorded as your turn) · /resume picks a past session · /compact restarts the context from a summary · ctrl+c twice quits';
 
 export default function App({ engine, task, resume }) {
   const { exit } = useApp();
@@ -63,6 +65,7 @@ export default function App({ engine, task, resume }) {
   const [menuIndex, setMenuIndex] = useState(0);
   const [elapsed, setElapsed] = useState(0);
   const [ctrlc, setCtrlc] = useState(0);
+  const [picker, setPicker] = useState(null);         // {items, index} | null
 
   const nextId = useRef(0);
   const phaseRef = useRef('connecting');
@@ -123,12 +126,18 @@ export default function App({ engine, task, resume }) {
         setHello(ev); modelRef.current = ev.model;
         append({ kind: 'banner', text: `${ev.model}${ev.user ? ` · ${ev.user}` : ''} · ${ev.cwd} · tools: ${ev.tools.join(', ')}` });
         if (task) engine.send({ cmd: 'start', task });
+        else if (resume === 'pick') { setPhaseBoth('idle'); engine.send({ cmd: 'sessions' }); }
         else if (resume) engine.send({ cmd: 'resume', name: resume });
         else setPhaseBoth('idle');
         break;
+      case 'sessions':
+        if (!ev.items || ev.items.length === 0) { append({ kind: 'info', text: 'no sessions yet' }); break; }
+        setPicker({ items: ev.items.slice(0, 12), index: 0 });
+        break;
       case 'session':
-        setSession(ev.name);
+        setSession(ev.name); setSpend(0);
         if (ev.model) modelRef.current = ev.model;
+        append({ kind: 'info', text: `session ${ev.name}` });
         break;
       case 'turn_start':
         turnT0.current = turnT0.current || Date.now();
@@ -222,6 +231,13 @@ export default function App({ engine, task, resume }) {
       return;
     }
     if (key.ctrl && input === 'd') { quit(); return; }
+    if (picker) {
+      if (key.upArrow) setPicker((p) => ({ ...p, index: (p.index + p.items.length - 1) % p.items.length }));
+      else if (key.downArrow || key.tab) setPicker((p) => ({ ...p, index: (p.index + 1) % p.items.length }));
+      else if (key.return) { const it = picker.items[picker.index]; setPicker(null); engine.send({ cmd: 'resume', name: it.name }); }
+      else if (key.escape) setPicker(null);
+      return;
+    }
     if (menu.length > 0) {
       if (key.upArrow) setMenuIndex((i) => (i + menu.length - 1) % menu.length);
       else if (key.downArrow) setMenuIndex((i) => (i + 1) % menu.length);
@@ -240,6 +256,8 @@ export default function App({ engine, task, resume }) {
     switch (cmd.name) {
       case '/quit': quit(); break;
       case '/help': append({ kind: 'info', text: HELP }); break;
+      case '/resume': engine.send({ cmd: 'sessions' }); break;
+      case '/compact': engine.send({ cmd: 'compact' }); break;
       case '/model':
         if (arg) { modelRef.current = arg; engine.send({ cmd: 'model', name: arg }); }
         else append({ kind: 'info', text: `model: ${modelRef.current}` });
@@ -342,10 +360,25 @@ export default function App({ engine, task, resume }) {
         </Box>
       )}
 
+      {picker && (
+        <Box flexDirection="column" paddingX={1} marginTop={1}>
+          <Text>pick a session to continue <Text dimColor>· enter continues · esc cancels</Text></Text>
+          {picker.items.map((it, i) => (
+            <Box key={it.name}>
+              <Text color="cyan" inverse={i === picker.index}>{(i === picker.index ? '❯ ' : '  ') + (it.when || '').padEnd(9)}</Text>
+              <Text dimColor={i !== picker.index}>
+                {'  '}{(it.instruction || '(untitled)').slice(0, Math.max(20, width - 40))}
+                {it.steps != null ? `  · ${it.steps} steps` : '  · on the server'}{it.cost_usd ? ` · ${fmtCost(it.cost_usd)}` : ''}{it.cwd ? ` · ${path.basename(it.cwd)}` : ''}
+              </Text>
+            </Box>
+          ))}
+        </Box>
+      )}
+
       <Box borderStyle="round" borderColor="gray" paddingX={1} marginTop={1}>
         <Text color="cyan">{'❯ '}</Text>
         <MultilineInput
-          value={value} onChange={setValue} onSubmit={onSubmit} focus={phase !== 'dead'}
+          value={value} onChange={setValue} onSubmit={onSubmit} focus={phase !== 'dead' && !picker}
           navActive={menu.length === 0} history={historyRef.current}
           placeholder={phase === 'busy' ? 'type to steer · esc to stop · !cmd runs a command' : (session ? 'what next?' : 'what are we doing?')}
         />

{hum_cli-0.1.1 → hum_cli-0.1.2}/tui/src/cli.jsx

@@ -12,7 +12,7 @@ function parseArgs(argv) {
   const a = { task: null, resume: null, cwd: process.cwd() };
   for (let i = 0; i < argv.length; i += 1) {
     const x = argv[i];
-    if (x === 'resume') { a.resume = argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : 'last'; }
+    if (x === 'resume') { a.resume = argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : 'pick'; }
     else if ((x === '-C' || x === '--cwd') && argv[i + 1]) { a.cwd = argv[++i]; }
     else if (x === '-h' || x === '--help') {
       process.stdout.write('usage: hum [task]  |  hum resume [name]\nIn a session: type to talk, !cmd runs a command, esc stops the model, / for commands.\n');