windhover 0.8.1__tar.gz → 0.10.0__tar.gz

{windhover-0.8.1 → windhover-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.8.1
+Version: 0.10.0
 Summary: Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view.
 Project-URL: Repository, https://github.com/justfeltlikerunning/windhover
 Author: justfeltlikerunning
@@ -81,8 +81,11 @@ graph.invoke(input, config={
 - **Clickable graph** — tap a node for health, latency, wiring, its **source code**, and recent executions with payloads.
 - **Error forensics** — failed runs show the full traceback; the failing node turns red on the
   graph, and the node's source renders with the **throwing line highlighted**.
-- **Human-in-the-loop aware** — a graph paused on `interrupt()` shows an amber **interrupted**
-  status plus the payload it's asking a human about.
+- **Human-in-the-loop console** — a paused graph shows an amber **interrupted** status with the
+  question it's asking; answer it (`Command(resume=…)`), redirect it (`Command(goto=…)`), set
+  static breakpoints per run (`interrupt_before`), **edit state** at any checkpoint
+  (`update_state`), or **fork** a thread from any historical checkpoint — all from the UI,
+  all pure LangGraph primitives.
 - **State evolution** — every trace shows which state keys each node wrote, in order.
 - **X-ray** — graphs with subgraphs get a canvas toggle that expands composite nodes
   (`get_graph(xray=True)`).
@@ -90,7 +93,14 @@ graph.invoke(input, config={
   status/tag/session filters, bookmarks, pagination, CSV/JSON export.
 - **Sessions** — group runs into threads/batches; roll-up tokens, cost, errors.
 - **Scores** — attach numeric evals to runs (API or UI): eval harnesses, LLM-as-judge, human review.
-- **Live tail** — open a running run and watch its spans arrive in real time.
+- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
+  progress via LangGraph's `get_stream_writer()`.
+- **Custom events** — `dispatch_custom_event("name", {...})` anywhere in your app lands as an
+  event marker in the trace, parented to the node that fired it.
+- **Retries + TTFT** — tenacity retries badge the span (`↻2`); streaming LLM calls record
+  time-to-first-token; cache-read / reasoning token details show on the model line.
+- **Memory browser** — graphs compiled with a LangGraph `Store` get a Memory view: browse
+  namespaces and search long-term memory items.
 - **Time-travel** — checkpointed graphs get a per-thread checkpoint browser: state, writes,
   and next-nodes at every superstep (`get_state_history`).
 - **Run diff** — compare any two runs node-by-node: identical vs differing outputs,

{windhover-0.8.1 → windhover-0.10.0}/README.md

@@ -62,8 +62,11 @@ graph.invoke(input, config={
 - **Clickable graph** — tap a node for health, latency, wiring, its **source code**, and recent executions with payloads.
 - **Error forensics** — failed runs show the full traceback; the failing node turns red on the
   graph, and the node's source renders with the **throwing line highlighted**.
-- **Human-in-the-loop aware** — a graph paused on `interrupt()` shows an amber **interrupted**
-  status plus the payload it's asking a human about.
+- **Human-in-the-loop console** — a paused graph shows an amber **interrupted** status with the
+  question it's asking; answer it (`Command(resume=…)`), redirect it (`Command(goto=…)`), set
+  static breakpoints per run (`interrupt_before`), **edit state** at any checkpoint
+  (`update_state`), or **fork** a thread from any historical checkpoint — all from the UI,
+  all pure LangGraph primitives.
 - **State evolution** — every trace shows which state keys each node wrote, in order.
 - **X-ray** — graphs with subgraphs get a canvas toggle that expands composite nodes
   (`get_graph(xray=True)`).
@@ -71,7 +74,14 @@ graph.invoke(input, config={
   status/tag/session filters, bookmarks, pagination, CSV/JSON export.
 - **Sessions** — group runs into threads/batches; roll-up tokens, cost, errors.
 - **Scores** — attach numeric evals to runs (API or UI): eval harnesses, LLM-as-judge, human review.
-- **Live tail** — open a running run and watch its spans arrive in real time.
+- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
+  progress via LangGraph's `get_stream_writer()`.
+- **Custom events** — `dispatch_custom_event("name", {...})` anywhere in your app lands as an
+  event marker in the trace, parented to the node that fired it.
+- **Retries + TTFT** — tenacity retries badge the span (`↻2`); streaming LLM calls record
+  time-to-first-token; cache-read / reasoning token details show on the model line.
+- **Memory browser** — graphs compiled with a LangGraph `Store` get a Memory view: browse
+  namespaces and search long-term memory items.
 - **Time-travel** — checkpointed graphs get a per-thread checkpoint browser: state, writes,
   and next-nodes at every superstep (`get_state_history`).
 - **Run diff** — compare any two runs node-by-node: identical vs differing outputs,

{windhover-0.8.1 → windhover-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "windhover"
-version = "0.8.1"
+version = "0.10.0"
 description = "Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view."
 readme = "README.md"
 requires-python = ">=3.10"

{windhover-0.8.1 → windhover-0.10.0}/tests/test_smoke.py

@@ -299,6 +299,130 @@ def test_datasets_and_scoring():
     print("datasets + scoring OK")
 
 
+def test_ttft_retry_custom_event_usage_detail():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="deep")
+    tr.on_chain_start({}, {"q": 1}, run_id="root", parent_run_id=None)
+    tr.on_chat_model_start({"kwargs": {"model": "gpt-4o"}}, [[]],
+                           run_id="llm1", parent_run_id="root")
+    time.sleep(0.02)
+    tr.on_llm_new_token("Hel", run_id="llm1")          # -> ttft stamped
+    tr.on_llm_new_token("lo", run_id="llm1")           # ignored (only first counts)
+
+    class RS:  # tenacity RetryCallState stand-in
+        attempt_number = 3
+    tr.on_retry(RS(), run_id="llm1")
+
+    class Msg:
+        content = "Hello"
+        usage_metadata = {"input_tokens": 900, "output_tokens": 40,
+                          "input_token_details": {"cache_read": 700},
+                          "output_token_details": {"reasoning": 12}}
+    class Gen:
+        text = "Hello"; message = Msg()
+    class Resp:
+        llm_output = None; generations = [[Gen()]]
+    tr.on_llm_end(Resp(), run_id="llm1")
+    tr.on_custom_event("checkpoint-saved", {"rows": 42}, run_id="root")
+    tr.on_chain_end({}, run_id="root")
+
+    d = s.run_detail(tr.run_id)
+    llm = [x for x in d["spans"] if x["type"] == "llm"][0]
+    assert llm["ttft_ms"] is not None and llm["ttft_ms"] >= 15
+    assert llm["retries"] == 3
+    assert llm["usage_detail"] == {"input_cache_read": 700, "output_reasoning": 12}
+    assert llm["prompt_tokens"] == 900
+    ev = [x for x in d["spans"] if x["type"] == "event"]
+    assert ev and ev[0]["name"] == "checkpoint-saved" and ev[0]["output"] == {"rows": 42}
+    print("ttft/retry/custom-event/usage-detail OK")
+
+
+def test_demo_memory_and_events_end_to_end():
+    """Demo graph writes long-term memory + dispatches a custom event — both
+    must be observable."""
+    import importlib
+    import windhover.demo_graph as dg
+    importlib.reload(dg)  # fresh InMemoryStore per test
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="demo")
+    dg.graph.invoke({"n": 7}, config={"callbacks": [tr],
+                                      "configurable": {"thread_id": "mem-t"}})
+    time.sleep(.1)
+    d = s.run_detail(tr.run_id)
+    ev = [x for x in d["spans"] if x["type"] == "event"]
+    assert ev and ev[0]["name"] == "summary-ready", [x["type"] for x in d["spans"]]
+    assert dg.graph.store is not None
+    items = dg.graph.store.search(("demo", "summaries"))
+    assert items and items[0].value["n"] == 21   # n=7 -> grow x3
+    assert ("demo", "summaries") in dg.graph.store.list_namespaces()
+    print("demo memory + custom event end-to-end OK")
+
+
+def test_hitl_interrupt_resume():
+    """Dynamic interrupt pauses (status interrupted); Command(resume) finishes."""
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.types import Command, interrupt
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+
+    class St(TypedDict):
+        x: int
+    def gate(st):
+        ok = interrupt({"question": f"allow x={st['x']}?"})
+        return {"x": st["x"] if ok else 0}
+    g = StateGraph(St)
+    g.add_node("gate", gate)
+    g.add_edge(START, "gate"); g.add_edge("gate", END)
+    app = g.compile(checkpointer=MemorySaver())
+    cfgc = {"configurable": {"thread_id": "hitl-1"}}
+
+    tr1 = SpanBuilder(db_sink(s), run_name="hitl")
+    out = app.invoke({"x": 5}, config={"callbacks": [tr1], **cfgc})
+    assert "__interrupt__" in out
+    time.sleep(.05)
+    assert s.run_detail(tr1.run_id)["status"] == "interrupted"
+
+    tr2 = SpanBuilder(db_sink(s), run_name="hitl")
+    out2 = app.invoke(Command(resume=True), config={"callbacks": [tr2], **cfgc})
+    assert out2["x"] == 5
+    time.sleep(.05)
+    assert s.run_detail(tr2.run_id)["status"] == "done"
+    print("HITL interrupt/resume OK")
+
+
+def test_static_breakpoint_and_state_edit():
+    """interrupt_before pauses with pending next; update_state edit sticks."""
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+
+    class St(TypedDict):
+        x: int
+    g = StateGraph(St)
+    g.add_node("inc", lambda st: {"x": st["x"] + 1})
+    g.add_node("mul", lambda st: {"x": st["x"] * 10})
+    g.add_edge(START, "inc"); g.add_edge("inc", "mul"); g.add_edge("mul", END)
+    app = g.compile(checkpointer=MemorySaver())
+    cfgc = {"configurable": {"thread_id": "bp-1"}}
+
+    tr = SpanBuilder(db_sink(s), run_name="bp")
+    for _ in app.stream({"x": 1}, config={"callbacks": [tr], **cfgc},
+                        stream_mode="updates", interrupt_before=["mul"]):
+        pass
+    st = app.get_state(cfgc)
+    assert st.next == ("mul",), st.next          # paused before mul
+    app.update_state(cfgc, {"x": 100})           # human edits the state
+    out = app.invoke(None, config=cfgc)          # continue
+    assert out["x"] == 1000, out                 # 100 * 10 — edit took effect
+    print("static breakpoint + state edit OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -314,4 +438,8 @@ if __name__ == "__main__":
     test_auth_check()
     test_thread_capture_and_history()
     test_datasets_and_scoring()
+    test_ttft_retry_custom_event_usage_detail()
+    test_demo_memory_and_events_end_to_end()
+    test_hitl_interrupt_resume()
+    test_static_breakpoint_and_state_edit()
     print("ALL SMOKE TESTS PASSED")

{windhover-0.8.1 → windhover-0.10.0}/windhover/demo_graph.py

@@ -24,11 +24,34 @@ def seed(s):
     if n < 0:
         raise ValueError(f"n must be non-negative, got {n} — the demo guard tripped")
     return {"n": n}
-def grow(s):       time.sleep(.3);  return {"n": s["n"] * 3}
+def grow(s):
+    time.sleep(.3)
+    grown = s["n"] * 3
+    if grown > 500:  # human-in-the-loop: big growth needs approval
+        from langgraph.types import interrupt
+        approved = interrupt({"question": f"grow {s['n']} -> {grown}? (true/false)"})
+        if not approved:
+            return {"n": s["n"]}
+    return {"n": grown}
 def parity(s):     time.sleep(.4);  return {"notes": ["even" if s["n"] % 2 == 0 else "odd"]}
 def sign(s):       time.sleep(.25); return {"notes": ["positive" if s["n"] > 0 else "non-positive"]}
 def magnitude(s):  time.sleep(.35); return {"notes": ["big" if abs(s["n"]) > 100 else "small"]}
-def summarize(s):  time.sleep(.2);  return {"notes": [f"n={s['n']}: " + ", ".join(s["notes"])]}
+def summarize(s):
+    time.sleep(.1)
+    try:  # progress + custom events + long-term memory, all observable in Windhover
+        from langgraph.config import get_stream_writer, get_store
+        writer = get_stream_writer()
+        writer({"stage": "summarize", "pct": 50})
+        from langchain_core.callbacks import dispatch_custom_event
+        dispatch_custom_event("summary-ready", {"n": s["n"], "parts": len(s["notes"])})
+        store = get_store()
+        if store is not None:
+            store.put(("demo", "summaries"), f"n-{s['n']}",
+                      {"n": s["n"], "notes": s["notes"]})
+    except Exception:
+        pass
+    time.sleep(.1)
+    return {"notes": [f"n={s['n']}: " + ", ".join(s["notes"])]}
 
 
 _g = StateGraph(State)
@@ -45,8 +68,9 @@ _g.add_edge("sign", "summarize")
 _g.add_edge("magnitude", "summarize")
 _g.add_edge("summarize", END)
 
-try:  # checkpointer makes the Time-travel view demoable; optional dependency surface
+try:  # checkpointer + store make Time-travel and Memory demoable
     from langgraph.checkpoint.memory import MemorySaver
-    graph = _g.compile(checkpointer=MemorySaver())
+    from langgraph.store.memory import InMemoryStore
+    graph = _g.compile(checkpointer=MemorySaver(), store=InMemoryStore())
 except Exception:
     graph = _g.compile()

{windhover-0.8.1 → windhover-0.10.0}/windhover/server.py

@@ -163,37 +163,41 @@ def _sse(ev: str, data: dict) -> str:
     return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
 
 
-@app.post("/api/run")
-async def api_run(request: Request):
-    if graph is None:
-        return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset)"}, 400)
-    try:
-        payload = await request.json()
-    except Exception:
-        payload = {}
-    session = payload.pop("_session", None)
-    tags = payload.pop("_tags", None)
-    thread = payload.pop("_thread", None)
-    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+def _stream_execution(graph_input, config, tracer, stream_kwargs=None):
+    """Shared SSE executor for /api/run and /api/threads/…/resume. Detects both
+    dynamic interrupts (__interrupt__ updates) and static breakpoints (stream
+    ends with pending next-nodes) and corrects the run status accordingly."""
     run_id = tracer.run_id
-    config = {"callbacks": [tracer]}
-    if thread or getattr(graph, "checkpointer", None) is not None:
-        # a checkpointed graph needs a thread; default to the run id so
-        # time-travel works out of the box
-        config["configurable"] = {"thread_id": thread or run_id}
     q: "queue.Queue" = queue.Queue()
 
     def worker():
         try:
             interrupted = False
-            for update in graph.stream(payload, config=config,
-                                       stream_mode="updates"):
-                for node in update:
+            for mode, chunk in graph.stream(graph_input, config=config,
+                                            stream_mode=["updates", "custom"],
+                                            **(stream_kwargs or {})):
+                if mode == "custom":
+                    # get_stream_writer() output from inside a node -> live progress
+                    q.put(("progress", {"data": _trunc(chunk, 600)}))
+                    continue
+                for node in chunk:
                     if node == "__interrupt__":
                         interrupted = True
                         q.put(("interrupt", {"run_id": run_id}))
                     else:
                         q.put(("node", {"node": node}))
+            if not interrupted and getattr(graph, "checkpointer", None) is not None:
+                try:  # static breakpoint: stream ended but nodes are pending
+                    st = graph.get_state(config)
+                    if st.next:
+                        interrupted = True
+                        q.put(("interrupt", {"run_id": run_id,
+                                             "next": list(st.next)}))
+                except Exception:
+                    pass
+            if interrupted:
+                # tracer closed the run as done on root end; correct it
+                store.close_run(run_id, "interrupted", int(time.time() * 1000))
             q.put(("interrupted" if interrupted else "done", {"run_id": run_id}))
         except Exception as e:
             # tracer already recorded the error span/close; surface to the client too
@@ -212,6 +216,86 @@ async def api_run(request: Request):
     return StreamingResponse(stream(), media_type="text/event-stream")
 
 
+@app.post("/api/run")
+async def api_run(request: Request):
+    if graph is None:
+        return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset)"}, 400)
+    try:
+        payload = await request.json()
+    except Exception:
+        payload = {}
+    session = payload.pop("_session", None)
+    tags = payload.pop("_tags", None)
+    thread = payload.pop("_thread", None)
+    pause_before = payload.pop("_interrupt_before", None)
+    pause_after = payload.pop("_interrupt_after", None)
+    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+    config = {"callbacks": [tracer]}
+    if thread or getattr(graph, "checkpointer", None) is not None:
+        # a checkpointed graph needs a thread; default to the run id so
+        # time-travel works out of the box
+        config["configurable"] = {"thread_id": thread or tracer.run_id}
+    sk = {}
+    if pause_before:
+        sk["interrupt_before"] = [str(n) for n in pause_before]
+    if pause_after:
+        sk["interrupt_after"] = [str(n) for n in pause_after]
+    return _stream_execution(payload, config, tracer, sk)
+
+
+@app.post("/api/threads/{thread_id}/resume")
+async def api_thread_resume(request: Request, thread_id: str):
+    """Human-in-the-loop: answer an interrupt (Command(resume=…)), redirect
+    (Command(goto=…)), continue past a static breakpoint (no body), or fork
+    from an earlier checkpoint (checkpoint_id)."""
+    if graph is None or getattr(graph, "checkpointer", None) is None:
+        return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    try:
+        from langgraph.types import Command
+    except Exception:
+        return JSONResponse({"error": "langgraph.types.Command unavailable"}, 500)
+    if "value" in body:
+        graph_input = Command(resume=body["value"])
+    elif body.get("goto"):
+        graph_input = Command(goto=str(body["goto"]), update=body.get("update"))
+    else:
+        graph_input = None  # plain continue (static breakpoint / after state edit)
+    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref,
+                         session=body.get("_session"),
+                         tags=(body.get("_tags") or []) + ["resume"])
+    configurable = {"thread_id": thread_id}
+    if body.get("checkpoint_id"):
+        configurable["checkpoint_id"] = str(body["checkpoint_id"])
+    config = {"callbacks": [tracer], "configurable": configurable}
+    return _stream_execution(graph_input, config, tracer)
+
+
+@app.post("/api/threads/{thread_id}/state")
+async def api_thread_update_state(request: Request, thread_id: str):
+    """Human-in-the-loop: edit state at the current (or a given) checkpoint —
+    LangGraph's update_state. Follow with …/resume to continue on the edit."""
+    if graph is None or getattr(graph, "checkpointer", None) is None:
+        return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
+    body = await request.json()
+    values = body.get("values")
+    if not isinstance(values, dict):
+        return JSONResponse({"error": "requires values (object of state keys)"}, 400)
+    configurable = {"thread_id": thread_id}
+    if body.get("checkpoint_id"):
+        configurable["checkpoint_id"] = str(body["checkpoint_id"])
+    try:
+        new_cfg = graph.update_state({"configurable": configurable}, values,
+                                     as_node=body.get("as_node"))
+        return JSONResponse({"ok": True, "checkpoint_id":
+                             (new_cfg.get("configurable") or {}).get("checkpoint_id")})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 400)
+
+
 @app.post("/api/ingest")
 async def api_ingest(request: Request):
     ev = await request.json()
@@ -340,6 +424,36 @@ def api_thread_history(thread_id: str, limit: int = 80):
     return JSONResponse({"thread_id": thread_id, "steps": steps})
 
 
+@app.get("/api/memory/namespaces")
+def api_memory_namespaces():
+    """LangGraph long-term memory (Store) browser — namespaces."""
+    st = getattr(graph, "store", None) if graph is not None else None
+    if st is None:
+        return JSONResponse({"error": "no local graph with a store"}, 404)
+    try:
+        return JSONResponse({"namespaces": [list(ns) for ns in st.list_namespaces()]})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 500)
+
+
+@app.get("/api/memory/items")
+def api_memory_items(namespace: str, query: str = None, limit: int = 50):
+    """Items in one namespace (dot-separated); optional semantic/text query."""
+    st = getattr(graph, "store", None) if graph is not None else None
+    if st is None:
+        return JSONResponse({"error": "no local graph with a store"}, 404)
+    try:
+        ns = tuple(namespace.split(".")) if namespace else ()
+        items = st.search(ns, query=query, limit=max(1, min(limit, 200)))
+        return JSONResponse({"namespace": namespace, "items": [
+            {"key": i.key, "value": _trunc(i.value, 3000),
+             "created_at": str(getattr(i, "created_at", "") or "") or None,
+             "updated_at": str(getattr(i, "updated_at", "") or "") or None,
+             "score": getattr(i, "score", None)} for i in items]})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 500)
+
+
 @app.get("/api/datasets")
 def api_datasets():
     return JSONResponse([{k: d[k] for k in ("id", "name", "n_items", "created_ms")}

{windhover-0.8.1 → windhover-0.10.0}/windhover/static/index.html

@@ -130,6 +130,58 @@ td.r,th.r{text-align:right}
 .empty{padding:56px 20px;text-align:center;color:var(--muted)}
 .empty .t{font-weight:600;color:var(--text2);margin-bottom:4px}
 
+/* ---------- human-in-the-loop ---------- */
+async function consumeRunStream(res){
+  const rd=res.body.getReader(),dec=new TextDecoder(); let buf='';
+  while(true){ const {value,done}=await rd.read(); if(done)break; buf+=dec.decode(value,{stream:true});
+    let ps=buf.split('\n\n'); buf=ps.pop();
+    for(const p of ps){ const ev=(p.match(/event: (.*)/)||[])[1],dm=(p.match(/data: (.*)/s)||[])[1]; if(!ev)continue; const d=dm?JSON.parse(dm):{};
+      if(ev==='node'&&cy){ cy.$id(d.node).addClass('running'); }
+      else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
+      else if(ev==='interrupted'){ toast('Paused again — awaiting human'); }
+      else if(ev==='done'){ toast('Resumed run complete'); }
+      else if(ev==='error'){ toast('Resume error: '+(d.message||'failed')); } } }
+  if(VIEW==='runs') loadRuns();
+}
+function parseMaybeJSON(v){ if(v==='')return undefined;
+  try{ return JSON.parse(v); }catch(e){ return v; } }
+window.resumeThread=async(tid)=>{
+  const raw=document.getElementById('hitl-val').value.trim();
+  const body={}; const v=parseMaybeJSON(raw); if(v!==undefined) body.value=v;
+  closeAll(); switchView('graph'); toast('Resuming thread '+tid.slice(0,8)+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
+  await consumeRunStream(res);
+};
+window.resumeGoto=async(tid)=>{
+  const g=document.getElementById('hitl-goto').value; if(!g) return toast('Pick a node first');
+  closeAll(); switchView('graph'); toast('Redirecting thread to '+g+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({goto:g})});
+  if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
+  await consumeRunStream(res);
+};
+window.rerunFrom=async(tid,cid)=>{
+  closeAll(); switchView('graph'); toast('Forking from checkpoint '+String(cid).slice(-8)+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({checkpoint_id:cid})});
+  if(!res.ok){ toast((await res.json()).error||'fork failed'); return; }
+  await consumeRunStream(res);
+};
+window.editState=async(tid,cid,valuesJson)=>{
+  const cur=window.prompt('Edit state values (JSON object) — applied via update_state:',valuesJson||'{}');
+  if(cur==null) return;
+  let values; try{ values=JSON.parse(cur); }catch(e){ return toast('Invalid JSON'); }
+  const body={values}; if(cid) body.checkpoint_id=cid;
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  const d=await res.json();
+  if(!res.ok) return toast(d.error||'update_state failed');
+  toast('State updated — new checkpoint '+String(d.checkpoint_id||'').slice(-8)+'; Resume to continue');
+  showHistory(tid);
+};
+
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
@@ -153,6 +205,10 @@ window.showHistory=async(tid)=>{
       <div class="tr-detail" id="${did}">
         ${s.writes!=null?kv('writes',s.writes):''}
         ${kv('state at this checkpoint',s.values)}
+        <div style="display:flex;gap:8px;margin:4px 0 10px">
+          <button class="btn ghost" onclick='rerunFrom("${esc(tid)}","${esc(s.checkpoint_id||'')}")'>⑂ Re-run from here</button>
+          <button class="btn ghost" onclick='editState("${esc(tid)}","${esc(s.checkpoint_id||'')}",${JSON.stringify(JSON.stringify(s.values??{}))})'>✎ Edit state</button>
+        </div>
       </div></div>`;
   }).join('')||'<div class="empty">No checkpoints recorded for this thread</div>';
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');
@@ -236,6 +292,7 @@ window.pickDiff=async(id)=>{
 .chip.tool{background:var(--chip-tool);color:var(--chip-tool-t)}
 .chip.retriever{background:var(--chip-ret);color:var(--chip-ret-t)}
 .chip.interrupt{background:var(--warn-weak);color:var(--warn)}
+.chip.event{background:var(--surface2);color:var(--text2);border:1px dashed var(--border2)}
 .tr-name{font-weight:600;font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .tr-name.err{color:var(--err)}
 .tr-gantt{height:6px;background:var(--surface2);border-radius:3px;position:relative;overflow:hidden}
@@ -296,6 +353,8 @@ textarea:focus{border-color:var(--accent)}
 .star.on{color:var(--warn)}
 .tagchip{display:inline-block;background:var(--accent-weak);color:var(--accent-text);font-size:10.5px;font-weight:600;
   padding:1.5px 7px;border-radius:5px;margin:1px 4px 1px 0;cursor:pointer}
+.pause-chip{background:var(--surface2);color:var(--text2);border:1px dashed var(--border2)}
+.pause-chip.on{background:var(--warn-weak);color:var(--warn);border-style:solid;border-color:var(--warn)}
 .scorechip{display:inline-block;background:var(--ok-weak);color:var(--ok);font-size:10.5px;font-weight:600;
   padding:1.5px 7px;border-radius:5px;margin:1px 4px 1px 0}
 .pager{display:flex;align-items:center;gap:12px;justify-content:flex-end;margin-top:10px;color:var(--muted);font-size:12.5px}
@@ -347,6 +406,8 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
 .tr-bar.tool{background:var(--chip-tool-t)}
 .tr-bar.retriever{background:var(--chip-ret-t)}
 .tr-bar.interrupt{background:var(--warn)}
+.tr-bar.event{background:var(--border2)}
+.badge-retry{font-family:var(--mono);font-size:10px;color:var(--warn);background:var(--warn-weak);border-radius:5px;padding:1px 6px;margin-left:6px}
 .charts .card:nth-child(2) .cbar{background:var(--chip-llm-t)}
 #cy{background:radial-gradient(circle,var(--border) 1px,transparent 1.5px) 0 0/24px 24px}
 .legend{font-family:var(--mono);font-size:10.5px;letter-spacing:.06em;text-transform:uppercase}
@@ -390,9 +451,10 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       <button data-v="graph" class="on">${ICON.graph} Graph</button>
       <button data-v="runs">${ICON.list} Runs</button>
       <button data-v="sessions">${ICON.layers} Sessions</button>
+      <button data-v="memory" id="nav-mem" style="display:none">${ICON.mem} Memory</button>
       <button data-v="stats">${ICON.chart} Stats</button>
     </nav>
-    <div class="side-foot"><span class="live-dot" id="live-dot" title="live topology"></span><span id="foot-note">watching</span><span class="spacer"></span><span class="mono" id="ver">v0.8</span></div>
+    <div class="side-foot"><span class="live-dot" id="live-dot" title="live topology"></span><span id="foot-note">watching</span><span class="spacer"></span><span class="mono" id="ver">v0.10</span></div>
   </aside>
 
   <main>
@@ -444,6 +506,16 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
           <div class="card"><div id="sess-wrap"><div class="empty">Loading…</div></div></div>
         </div>
       </div>
+      <div id="view-memory" style="display:none">
+        <div class="page">
+          <div class="page-head"><h1>Memory</h1><span class="sub">LangGraph long-term store</span></div>
+          <div class="rtools">
+            <select id="mem-ns"></select>
+            <input type="search" id="mem-q" placeholder="Search this namespace…">
+          </div>
+          <div class="card"><div id="mem-wrap"><div class="empty">Loading…</div></div></div>
+        </div>
+      </div>
       <div id="view-stats" style="display:none">
         <div class="page">
           <div class="page-head"><h1>Stats</h1><span class="sub">all recorded runs</span></div>
@@ -458,6 +530,7 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
   <button data-v="graph" class="on">${ICON.graph}<span>Graph</span></button>
   <button data-v="runs">${ICON.list}<span>Runs</span></button>
   <button data-v="sessions">${ICON.layers}<span>Sessions</span></button>
+  <button data-v="memory" class="nav-mem" style="display:none">${ICON.mem}<span>Memory</span></button>
   <button data-v="stats">${ICON.chart}<span>Stats</span></button>
 </div>
 
@@ -481,6 +554,8 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       <input id="run-session" placeholder="session (optional)" style="flex:1;min-width:130px">
       <input id="run-tags" placeholder="tags, comma-separated (optional)" style="flex:1;min-width:160px">
     </div>
+    <div class="hint" style="margin:8px 0 4px">Pause before (static breakpoints — resume from the run drawer):</div>
+    <div id="pause-chips" style="display:flex;flex-wrap:wrap;gap:6px"></div>
     <div class="actions">
       <button class="btn ghost" onclick="closeAll()">Cancel</button>
       <button class="btn primary" id="do-run">${ICON.play} Run</button>
@@ -497,6 +572,7 @@ const ICON = {
   list:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M8 6h12M8 12h12M8 18h12"/><circle cx="4" cy="6" r="1.1" fill="currentColor" stroke="none"/><circle cx="4" cy="12" r="1.1" fill="currentColor" stroke="none"/><circle cx="4" cy="18" r="1.1" fill="currentColor" stroke="none"/></svg>',
   chart:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M4 20V9M10 20V4M16 20v-7M21 20H3"/></svg>',
   layers:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linejoin="round"><path d="M12 3 3 8l9 5 9-5-9-5z"/><path d="M3 13l9 5 9-5"/></svg>',
+  mem:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><ellipse cx="12" cy="5.5" rx="7.5" ry="2.8"/><path d="M4.5 5.5v6c0 1.6 3.4 2.8 7.5 2.8s7.5-1.2 7.5-2.8v-6"/><path d="M4.5 11.5v6c0 1.6 3.4 2.8 7.5 2.8s7.5-1.2 7.5-2.8v-6"/></svg>',
   play:'<svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor"><path d="M7 4.8v14.4c0 .8.9 1.3 1.6.9l11-7.2c.6-.4.6-1.4 0-1.8l-11-7.2c-.7-.4-1.6.1-1.6.9z"/></svg>',
   moon:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M20 13.5A8 8 0 1 1 10.5 4 6.5 6.5 0 0 0 20 13.5z"/></svg>',
   x:'<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M6 6l12 12M18 6L6 18"/></svg>',
@@ -673,20 +749,27 @@ function switchView(v){ VIEW=v;
   if(location.hash!=='#'+v) history.replaceState(null,'','#'+v);
   $$('.nav button,.bottom-nav button').forEach(b=>b.classList.toggle('on',b.dataset.v===v));
   $('#crumb').textContent=v[0].toUpperCase()+v.slice(1);
-  for(const k of ['graph','runs','sessions','stats'])
+  for(const k of ['graph','runs','sessions','memory','stats'])
     $('#view-'+k).style.display=v===k?'':'none';
-  if(v==='runs')loadRuns(); if(v==='sessions')loadSessions(); if(v==='stats'){loadStats();loadDatasets();}
+  if(v==='runs')loadRuns(); if(v==='sessions')loadSessions(); if(v==='memory')loadMemory();
+  if(v==='stats'){loadStats();loadDatasets();}
   if(cy&&v==='graph')setTimeout(()=>cy.resize(),40);
 }
 $$('.nav button,.bottom-nav button').forEach(b=>b.onclick=()=>switchView(b.dataset.v));
 
 /* ---------- new run ---------- */
 $('#newrun').onclick=async()=>{ let tpl={}; try{tpl=(await(await fetch('/api/schema')).json()).template||{};}catch(e){}
-  $('#input-json').value=JSON.stringify(tpl,null,2); $('#scrim').classList.add('on'); $('#modal').classList.add('on'); };
+  $('#input-json').value=JSON.stringify(tpl,null,2);
+  const pc=document.getElementById('pause-chips');
+  if(pc&&cy) pc.innerHTML=cy.nodes().filter(n=>!n.data('terminal')).map(n=>
+    `<span class="tagchip pause-chip" data-n="${esc(n.id())}" onclick="this.classList.toggle('on')">${esc(n.id())}</span>`).join('');
+  $('#scrim').classList.add('on'); $('#modal').classList.add('on'); };
 $('#do-run').onclick=async()=>{ let input; try{input=JSON.parse($('#input-json').value||'{}');}catch(e){return toast('Invalid JSON input');}
   const sess=$('#run-session').value.trim();
   const tags=$('#run-tags').value.split(',').map(s=>s.trim()).filter(Boolean);
   if(sess)input._session=sess; if(tags.length)input._tags=tags;
+  const paused=[...document.querySelectorAll('.pause-chip.on')].map(e=>e.dataset.n);
+  if(paused.length) input._interrupt_before=paused;
   closeAll(); switchView('graph'); await runNow(input); };
 
 async function runNow(input){
@@ -700,6 +783,7 @@ async function runNow(input){
       for(const p of ps){ const ev=(p.match(/event: (.*)/)||[])[1],dm=(p.match(/data: (.*)/s)||[])[1]; if(!ev)continue; const d=dm?JSON.parse(dm):{};
         if(ev==='node'){ cy.$id(prev).addClass('done').removeClass('running'); cy.$id(d.node).addClass('running');
           cy.edges(`[source="${prev}"][target="${d.node}"]`).addClass('flow'); prev=d.node; }
+        else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
         else if(ev==='interrupt'){ toast('Run paused at an interrupt — awaiting resume'); }
         else if(ev==='interrupted'){ cy.$id(prev).addClass('running'); toast('Run interrupted — see Runs for the payload'); }
         else if(ev==='done'){ cy.$id(prev).addClass('done').removeClass('running'); cy.$id('__end__').addClass('done'); toast('Run complete — saved to Runs'); }
@@ -804,6 +888,19 @@ async function openRun(id){
       <span class="chip node">${esc(s.name)}</span>
       ${Object.keys(s.output).map(k=>`<span class="tagchip" style="cursor:default">${esc(k)}</span>`).join('')}
       <span style="color:var(--muted);font-size:11px;margin-left:auto" class="mono">${s.dur_ms!=null?fmtms(s.dur_ms):''}</span></div>`).join('');
+  if(r.status==='interrupted'&&r.thread_id){
+    const ivs=r.spans.filter(s=>s.type==='interrupt'); const iv=ivs.find(s=>s.output!=null)||ivs.pop();
+    html += `<div class="kv" style="margin-top:14px"><div class="k" style="color:var(--warn)">interrupt — awaiting human</div>
+      ${iv&&iv.output!=null?`<pre>${esc(JSON.stringify(iv.output,null,2))}</pre>`:'<pre>paused at a breakpoint</pre>'}
+      <div class="scoreadd" style="margin-top:8px">
+        <input id="hitl-val" placeholder='resume value — JSON or text (blank = just continue)' style="flex:1;min-width:200px">
+        <button class="btn primary" onclick="resumeThread('${esc(r.thread_id)}')">Resume</button>
+      </div>
+      <div class="scoreadd">
+        <select id="hitl-goto"><option value="">goto node (optional)…</option></select>
+        <button class="btn ghost" onclick="resumeGoto('${esc(r.thread_id)}')">Send to node</button>
+      </div></div>`;
+  }
   html += `<div class="kv" style="margin-top:14px"><div class="k">scores</div></div>
     ${(r.scores||[]).map(sc=>`<div class="scorerow"><span class="scorechip">${esc(sc.name)} ${sc.value}</span>
       ${sc.comment?`<span style="color:var(--muted);font-size:12px">${esc(sc.comment)}</span>`:''}
@@ -820,6 +917,9 @@ async function openRun(id){
   $('#d-body').innerHTML=html;
   openIds.forEach(i=>{const e=document.getElementById(i); if(e){e.style.display='block';
     const row=e.previousElementSibling; row&&row.querySelector('.caret')?.classList.add('open');}});
+  const gsel=document.getElementById('hitl-goto');
+  if(gsel&&cy) gsel.innerHTML='<option value="">goto node (optional)…</option>'+
+    cy.nodes().filter(n=>!n.data('terminal')).map(n=>`<option>${esc(n.id())}</option>`).join('');
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');
   clearTimeout(window.__liveT);
   if(r.status==='running')
@@ -843,6 +943,7 @@ function renderSpans(list,byParent,total,depth){
     const kids=byParent[s.id]||[];
     const left=((s.offset_ms||0)/total*100).toFixed(2), width=Math.max(1.2,(s.dur_ms||0)/total*100).toFixed(2);
     const meta=[s.dur_ms!=null?s.dur_ms+'ms':null,
+      s.ttft_ms!=null?'ttft '+s.ttft_ms+'ms':null,
       s.type==='llm'&&(s.prompt_tokens!=null||s.completion_tokens!=null)?fmtk((s.prompt_tokens||0)+(s.completion_tokens||0))+'t':null,
       s.cost_usd!=null?'$'+s.cost_usd.toFixed(4):null].filter(Boolean).join(' · ');
     const did='sp'+s.id;
@@ -850,12 +951,12 @@ function renderSpans(list,byParent,total,depth){
       <div class="tr-row" onclick="tog('${did}',this)">
         <div class="tr-main"><span class="indent" style="width:${depth*18}px"></span>
           <span class="caret">▶</span><span class="chip ${s.type}">${s.type}</span>
-          <span class="tr-name ${s.status==='error'?'err':''}">${esc(s.name||s.type)}</span></div>
+          <span class="tr-name ${s.status==='error'?'err':''}">${esc(s.name||s.type)}</span>${s.retries?`<span class="badge-retry">↻${s.retries}</span>`:''}</div>
         <div class="tr-gantt"><div class="tr-bar ${s.type}" style="left:${left}%;width:${width}%"></div></div>
         <div class="tr-meta">${meta}</div>
       </div>
       <div class="tr-detail" id="${did}">
-        ${s.model?`<div class="kv"><div class="k">model</div><pre>${esc(s.model)}${s.prompt_tokens!=null?`  ·  ${s.prompt_tokens} in / ${s.completion_tokens||0} out`:''}</pre></div>`:''}
+        ${s.model?`<div class="kv"><div class="k">model</div><pre>${esc(s.model)}${s.prompt_tokens!=null?`  ·  ${s.prompt_tokens} in / ${s.completion_tokens||0} out`:''}${s.usage_detail?'  ·  '+esc(Object.entries(s.usage_detail).map(([k,v])=>`${v} ${k.replace('input_','').replace('output_','')}`).join(', ')):''}</pre></div>`:''}
         ${s.error?`<div class="kv"><div class="k">error${s.type==='node'?`<button class="copy" onclick="showSpanSource('${s.id}')">view source</button>`:''}</div><pre class="err">${esc(s.error)}</pre><div id="src-${s.id}"></div></div>`:''}
         ${s.input!=null?kv('input',s.input):''}
         ${s.output!=null?kv('output',s.output):''}
@@ -887,6 +988,58 @@ window.showSpanSource=async(sid)=>{
                   :'<pre>no source available for this node (external run, or inspect could not trace it)</pre>';
 };
 
+/* ---------- human-in-the-loop ---------- */
+async function consumeRunStream(res){
+  const rd=res.body.getReader(),dec=new TextDecoder(); let buf='';
+  while(true){ const {value,done}=await rd.read(); if(done)break; buf+=dec.decode(value,{stream:true});
+    let ps=buf.split('\n\n'); buf=ps.pop();
+    for(const p of ps){ const ev=(p.match(/event: (.*)/)||[])[1],dm=(p.match(/data: (.*)/s)||[])[1]; if(!ev)continue; const d=dm?JSON.parse(dm):{};
+      if(ev==='node'&&cy){ cy.$id(d.node).addClass('running'); }
+      else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
+      else if(ev==='interrupted'){ toast('Paused again — awaiting human'); }
+      else if(ev==='done'){ toast('Resumed run complete'); }
+      else if(ev==='error'){ toast('Resume error: '+(d.message||'failed')); } } }
+  if(VIEW==='runs') loadRuns();
+}
+function parseMaybeJSON(v){ if(v==='')return undefined;
+  try{ return JSON.parse(v); }catch(e){ return v; } }
+window.resumeThread=async(tid)=>{
+  const raw=document.getElementById('hitl-val').value.trim();
+  const body={}; const v=parseMaybeJSON(raw); if(v!==undefined) body.value=v;
+  closeAll(); switchView('graph'); toast('Resuming thread '+tid.slice(0,8)+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
+  await consumeRunStream(res);
+};
+window.resumeGoto=async(tid)=>{
+  const g=document.getElementById('hitl-goto').value; if(!g) return toast('Pick a node first');
+  closeAll(); switchView('graph'); toast('Redirecting thread to '+g+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({goto:g})});
+  if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
+  await consumeRunStream(res);
+};
+window.rerunFrom=async(tid,cid)=>{
+  closeAll(); switchView('graph'); toast('Forking from checkpoint '+String(cid).slice(-8)+'…');
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({checkpoint_id:cid})});
+  if(!res.ok){ toast((await res.json()).error||'fork failed'); return; }
+  await consumeRunStream(res);
+};
+window.editState=async(tid,cid,valuesJson)=>{
+  const cur=window.prompt('Edit state values (JSON object) — applied via update_state:',valuesJson||'{}');
+  if(cur==null) return;
+  let values; try{ values=JSON.parse(cur); }catch(e){ return toast('Invalid JSON'); }
+  const body={values}; if(cid) body.checkpoint_id=cid;
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state',
+    {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
+  const d=await res.json();
+  if(!res.ok) return toast(d.error||'update_state failed');
+  toast('State updated — new checkpoint '+String(d.checkpoint_id||'').slice(-8)+'; Resume to continue');
+  showHistory(tid);
+};
+
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
@@ -910,6 +1063,10 @@ window.showHistory=async(tid)=>{
       <div class="tr-detail" id="${did}">
         ${s.writes!=null?kv('writes',s.writes):''}
         ${kv('state at this checkpoint',s.values)}
+        <div style="display:flex;gap:8px;margin:4px 0 10px">
+          <button class="btn ghost" onclick='rerunFrom("${esc(tid)}","${esc(s.checkpoint_id||'')}")'>⑂ Re-run from here</button>
+          <button class="btn ghost" onclick='editState("${esc(tid)}","${esc(s.checkpoint_id||'')}",${JSON.stringify(JSON.stringify(s.values??{}))})'>✎ Edit state</button>
+        </div>
       </div></div>`;
   }).join('')||'<div class="empty">No checkpoints recorded for this thread</div>';
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');
@@ -1009,6 +1166,37 @@ function fmtk(n){ return n<1000?String(n):(n/1000).toFixed(1)+'k'; }
 function ago(ms){ const s=(Date.now()-ms)/1000; if(s<60)return Math.round(s)+'s ago'; if(s<3600)return Math.round(s/60)+'m ago'; if(s<86400)return Math.round(s/3600)+'h ago'; return Math.round(s/86400)+'d ago'; }
 let tT; function toast(m){ const t=$('#toast'); t.textContent=m; t.classList.add('show'); clearTimeout(tT); tT=setTimeout(()=>t.classList.remove('show'),2600); }
 
+let MEM_NS=[];
+async function probeMemory(){
+  try{ const r=await fetch('/api/memory/namespaces'); if(!r.ok) return;
+    MEM_NS=(await r.json()).namespaces||[];
+    document.getElementById('nav-mem').style.display='';
+    const m=document.querySelector('.bottom-nav .nav-mem'); if(m)m.style.display='';
+  }catch(e){}
+}
+async function loadMemory(){
+  const sel=document.getElementById('mem-ns');
+  try{ const r=await fetch('/api/memory/namespaces'); MEM_NS=(await r.json()).namespaces||[]; }catch(e){}
+  const cur=sel.value;
+  sel.innerHTML=MEM_NS.map(ns=>`<option value="${esc(ns.join('.'))}">${esc(ns.join(' / '))}</option>`).join('');
+  if(cur) sel.value=cur;
+  const ns=sel.value;
+  const w=document.getElementById('mem-wrap');
+  if(!ns){ w.innerHTML='<div class="empty"><div class="t">No memories yet</div>Nodes write with <span class="mono">get_store().put(namespace, key, value)</span> — items appear here.</div>'; return; }
+  const q=document.getElementById('mem-q').value.trim();
+  const p=new URLSearchParams({namespace:ns}); if(q)p.set('query',q);
+  let d={items:[]}; try{ d=await(await fetch('/api/memory/items?'+p)).json(); }catch(e){}
+  w.innerHTML=(d.items||[]).length?`<div style="overflow:auto"><table>
+    <thead><tr><th>Key</th><th>Value</th><th class="r">Updated</th></tr></thead>
+    <tbody>${d.items.map(i=>`<tr>
+      <td class="mono" style="font-weight:600;white-space:nowrap">${esc(i.key)}</td>
+      <td><pre style="margin:0;white-space:pre-wrap;word-break:break-word;font:12px/1.5 var(--mono);max-width:640px">${esc(JSON.stringify(i.value,null,1)).slice(0,600)}</pre></td>
+      <td class="r" style="color:var(--muted);white-space:nowrap">${i.updated_at?esc(String(i.updated_at).slice(0,19).replace('T',' ')):'—'}</td></tr>`).join('')}</tbody></table></div>`
+    :'<div class="empty">Nothing in this namespace'+(q?' matching that query':'')+'.</div>';
+}
+document.addEventListener('change',e=>{ if(e.target&&e.target.id==='mem-ns') loadMemory(); });
+let memQT; document.addEventListener('input',e=>{ if(e.target&&e.target.id==='mem-q'){ clearTimeout(memQT); memQT=setTimeout(loadMemory,300); } });
+
 async function loadDatasets(){
   const w=document.getElementById('ds-wrap'); if(!w) return;
   let ds=[]; try{ ds=await(await fetch('/api/datasets')).json(); }catch(e){}
@@ -1027,7 +1215,7 @@ window.runDataset=async(id,name)=>{
   toast('Eval started: '+d.items+' items → session '+d.session);
 };
 window.delDataset=async(id)=>{ await fetch('/api/datasets/'+id,{method:'DELETE'}); loadDatasets(); };
-loadGraph(); liveTopology();
+loadGraph(); liveTopology(); probeMemory();
 /* deep links: #runs #sessions #stats #run=<id> */
 (function(){ const h=location.hash.slice(1);
   if(h==='runs'||h==='sessions'||h==='stats') switchView(h);

{windhover-0.8.1 → windhover-0.10.0}/windhover/store.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import json, os, sqlite3, threading, time, uuid
 from typing import Any, Optional
 
-SCHEMA_VERSION = 5
+SCHEMA_VERSION = 6
 _lock = threading.Lock()
 
 
@@ -68,6 +68,11 @@ class Store:
                 c.execute("ALTER TABLE runs ADD COLUMN bookmarked INTEGER DEFAULT 0")
             if "thread_id" not in cols:
                 c.execute("ALTER TABLE runs ADD COLUMN thread_id TEXT")
+            scols = [r[1] for r in c.execute("PRAGMA table_info(spans)").fetchall()]
+            for col, typ in (("retries", "INTEGER"), ("ttft_ms", "INTEGER"),
+                             ("usage_detail", "TEXT")):
+                if col not in scols:
+                    c.execute(f"ALTER TABLE spans ADD COLUMN {col} {typ}")
             try:
                 c.execute("SELECT count(*) FROM json_each('[1]')")
                 self.has_json1 = True
@@ -133,15 +138,18 @@ class Store:
         with _lock, self._conn() as c:
             c.execute("""INSERT OR REPLACE INTO spans
               (id,run_id,parent_id,seq,type,name,status,started_ms,ended_ms,offset_ms,
-               dur_ms,input,output,model,prompt_tokens,completion_tokens,cost_usd,error)
-              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+               dur_ms,input,output,model,prompt_tokens,completion_tokens,cost_usd,error,
+               retries,ttft_ms,usage_detail)
+              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
               (s["id"], s["run_id"], s.get("parent_id"), s.get("seq", 0), s["type"],
                s.get("name"), s.get("status", "ok"), s.get("started_ms"), s.get("ended_ms"),
                s.get("offset_ms"), s.get("dur_ms"),
                json.dumps(s.get("input"), default=str) if s.get("input") is not None else None,
                json.dumps(s.get("output"), default=str) if s.get("output") is not None else None,
                s.get("model"), s.get("prompt_tokens"), s.get("completion_tokens"),
-               s.get("cost_usd"), s.get("error")))
+               s.get("cost_usd"), s.get("error"),
+               s.get("retries"), s.get("ttft_ms"),
+               json.dumps(s.get("usage_detail")) if s.get("usage_detail") else None))
             if self.has_fts:
                 c.execute("DELETE FROM span_fts WHERE span_id=?", (s["id"],))
                 c.execute("INSERT INTO span_fts(text,span_id,run_id) VALUES(?,?,?)",
@@ -316,7 +324,7 @@ class Store:
         for k in ("input", "tags"):
             d[k] = json.loads(d[k]) if d.get(k) else None
         for s in spans:
-            for k in ("input", "output"):
+            for k in ("input", "output", "usage_detail"):
                 s[k] = json.loads(s[k]) if s.get(k) else None
         d["spans"] = spans
         d["scores"] = scores

{windhover-0.8.1 → windhover-0.10.0}/windhover/tracer.py

@@ -77,24 +77,31 @@ def _model_name(serialized: dict, kw: dict) -> str:
     return ids[-1] if ids else "llm"
 
 
-def _usage(response: Any) -> tuple[Optional[int], Optional[int]]:
+def _usage(response: Any) -> tuple[Optional[int], Optional[int], Optional[dict]]:
+    """(prompt, completion, detail) — detail carries cache_read/cache_creation/
+    reasoning token counts when the provider reports them."""
     # OpenAI-style aggregate
     out = getattr(response, "llm_output", None) or {}
     for key in ("token_usage", "usage"):
         u = out.get(key) if isinstance(out, dict) else None
         if u:
             return (u.get("prompt_tokens") or u.get("input_tokens"),
-                    u.get("completion_tokens") or u.get("output_tokens"))
+                    u.get("completion_tokens") or u.get("output_tokens"), None)
     # per-generation usage_metadata (chat models)
     try:
         for gens in response.generations:
             for g in gens:
                 um = getattr(getattr(g, "message", None), "usage_metadata", None)
                 if um:
-                    return um.get("input_tokens"), um.get("output_tokens")
+                    detail = {}
+                    for side in ("input_token_details", "output_token_details"):
+                        for k, v in (um.get(side) or {}).items():
+                            if v:
+                                detail[f"{side.split('_')[0]}_{k}"] = v
+                    return um.get("input_tokens"), um.get("output_tokens"), detail or None
     except Exception:
         pass
-    return None, None
+    return None, None, None
 
 
 def _gen_text(response: Any) -> str:
@@ -130,6 +137,7 @@ class SpanBuilder(BaseCallbackHandler):
         self._open: dict[str, dict] = {}   # langchain run_id -> pending span
         self._span_of: dict[str, str] = {} # langchain run_id -> our span id (for parent links)
         self._seq = 0
+        self._interrupted = False
 
     # -- infra --
     def _emit(self, ev: dict) -> None:
@@ -142,7 +150,7 @@ class SpanBuilder(BaseCallbackHandler):
         return int((t - (self._t0 or t)) * 1000)
 
     def _finish_span(self, info: dict, *, output=None, status="ok", error=None,
-                     model=None, pt=None, ct=None):
+                     model=None, pt=None, ct=None, usage_detail=None):
         now = time.time()
         sid = info["span_id"]
         self._emit({"kind": "span", "id": sid, "run_id": self.run_id,
@@ -153,7 +161,10 @@ class SpanBuilder(BaseCallbackHandler):
                     "dur_ms": int((now - info["t"]) * 1000),
                     "input": info.get("input"), "output": output, "model": model,
                     "prompt_tokens": pt, "completion_tokens": ct,
-                    "cost_usd": cost_of(model, pt, ct), "error": error})
+                    "cost_usd": cost_of(model, pt, ct), "error": error,
+                    "retries": info.get("retries"),
+                    "ttft_ms": int(info["ttft"] * 1000) if info.get("ttft") is not None else None,
+                    "usage_detail": usage_detail})
         self._seq += 1
 
     # -- chains / nodes --
@@ -196,8 +207,11 @@ class SpanBuilder(BaseCallbackHandler):
             # LangGraph human-in-the-loop: a paused graph surfaces __interrupt__
             # in its final output — that's a pause awaiting Command(resume=...),
             # not a completion.
-            interrupted = isinstance(outputs, dict) and "__interrupt__" in outputs
-            if interrupted:
+            interrupted = self._interrupted or (
+                isinstance(outputs, dict) and "__interrupt__" in outputs)
+            if interrupted and not self._interrupted:
+                # marker not yet emitted by the GraphInterrupt path
+                self._interrupted = True
                 self._finish_span(
                     {"span_id": uuid.uuid4().hex[:12], "type": "interrupt",
                      "name": "interrupt", "t": time.time(), "parent": None,
@@ -209,6 +223,32 @@ class SpanBuilder(BaseCallbackHandler):
 
     def on_chain_error(self, error, *, run_id=None, **kw):
         info = self._open.pop(run_id, None)
+        # LangGraph signals a human-in-the-loop pause by raising GraphInterrupt
+        # through the node — that's a pause, not a failure.
+        if type(error).__name__ in ("GraphInterrupt", "NodeInterrupt"):
+            payload = []
+            try:
+                for i in (error.args[0] if error.args else []):
+                    payload.append(getattr(i, "value", str(i)))
+            except Exception:
+                pass
+            if info:
+                self._finish_span(info, status="interrupted",
+                                  output=_trunc(payload) if payload else None)
+            if not self._interrupted:  # one marker span per pause
+                self._interrupted = True
+                now = time.time()
+                self._emit({"kind": "span", "id": uuid.uuid4().hex[:12],
+                            "run_id": self.run_id, "parent_id": None,
+                            "seq": self._seq, "type": "interrupt", "name": "interrupt",
+                            "status": "ok", "started_ms": int(now * 1000),
+                            "ended_ms": int(now * 1000), "offset_ms": self._rel(now),
+                            "dur_ms": 0, "input": None,
+                            "output": _trunc(payload) if payload else None,
+                            "model": None, "prompt_tokens": None,
+                            "completion_tokens": None, "cost_usd": None, "error": None})
+                self._seq += 1
+            return
         err = _err_text(error)
         if info:
             self._finish_span(info, status="error", error=err)
@@ -235,15 +275,41 @@ class SpanBuilder(BaseCallbackHandler):
         info = self._open.pop(run_id, None)
         if not info:
             return
-        pt, ct = _usage(response)
+        pt, ct, detail = _usage(response)
         self._finish_span(info, output=_gen_text(response)[:4000],
-                          model=info["name"], pt=pt, ct=ct)
+                          model=info["name"], pt=pt, ct=ct, usage_detail=detail)
 
     def on_llm_error(self, error, *, run_id=None, **kw):
         info = self._open.pop(run_id, None)
         if info:
             self._finish_span(info, status="error", error=_err_text(error), model=info["name"])
 
+    def on_llm_new_token(self, token, *, run_id=None, **kw):
+        # streaming: first token stamps time-to-first-token
+        info = self._open.get(run_id)
+        if info is not None and "ttft" not in info:
+            info["ttft"] = time.time() - info["t"]
+
+    # -- retries (tenacity, e.g. rate limits) --
+    def on_retry(self, retry_state, *, run_id=None, **kw):
+        info = self._open.get(run_id)
+        if info is not None:
+            info["retries"] = getattr(retry_state, "attempt_number", None) or \
+                              (info.get("retries") or 0) + 1
+
+    # -- custom events (langchain dispatch_custom_event) --
+    def on_custom_event(self, name, data, *, run_id=None, **kw):
+        now = time.time()
+        self._emit({"kind": "span", "id": uuid.uuid4().hex[:12], "run_id": self.run_id,
+                    "parent_id": self._span_of.get(run_id),
+                    "seq": self._seq, "type": "event", "name": str(name), "status": "ok",
+                    "started_ms": int(now * 1000), "ended_ms": int(now * 1000),
+                    "offset_ms": self._rel(now), "dur_ms": 0,
+                    "input": None, "output": _trunc(data), "model": None,
+                    "prompt_tokens": None, "completion_tokens": None,
+                    "cost_usd": None, "error": None})
+        self._seq += 1
+
     # -- retrievers (LangChain RAG) --
     def on_retriever_start(self, serialized, query, *, run_id=None, parent_run_id=None, **kw):
         sid = uuid.uuid4().hex[:12]