claude-finops 0.15.0 → 0.16.0

package/README.md

@@ -438,18 +438,24 @@ files on Windows.
   "Add" runs `claude mcp add -s user …`; "Create skill" writes `~/.claude/skills/<name>/SKILL.md`.
   The strongest skill suggestions also appear in **⚡ Act now** on the overview.
 - **Compact** (Running sessions, Recent, Act now, session rows) types `/compact` into that session's
-  terminal: tmux, Terminal.app, iTerm2 or the Windows console. Anywhere else it copies the
+  terminal: tmux, herdr, Terminal.app, iTerm2 or the Windows console. Anywhere else it copies the
   command for you to paste. It asks you to click twice.
 - **Hand over / split** (Running sessions) writes a brief of the session to
-  `~/.claude/finops-handoffs/` and opens fresh session(s) in new terminals, one per sub-task if
-  you list them; it can close the old session (resumable).
+  `~/.claude/finops-handoffs/` and opens fresh session(s) in new terminals (a new herdr tab in the
+  same workspace when the session runs in herdr), one per sub-task if you list them; it can close
+  the old session (resumable).
+- **Prompts** (Running sessions) shows a session's first prompt and its latest five, so you can
+  tell which session is which before you close it.
+- **Rename** (Running sessions) types `/rename <name>` into that session's terminal, so Claude
+  Code saves the name itself. In herdr, the agents sidebar gets the same name. Anywhere it can't
+  type, the command lands on your clipboard.
 - **Recent** (clock icon in the top bar, or press `R`) opens a side panel on any page: running sessions first,
   with Resume, Compact and Stop (Interrupt), then past sessions newest first. Click a session to
   list its prompts, and click a prompt for its full details. Search matches your prompt text.
   It covers all dates but keeps the agent and project filters. Close and Force kill stay on
   Running sessions.
-- **Interrupt / Close / Force kill** (Running sessions) send the session's process a signal.
-  Each asks you to click twice. Interrupt is macOS/Linux only: on Windows there is no way to
+- **Interrupt / Close / Force kill** (Running sessions) send the session's process a signal
+  (in herdr, Interrupt presses Esc in the session's pane instead). Each asks you to click twice. Interrupt is macOS/Linux only: on Windows there is no way to
   interrupt one console process without hitting the others in its window.
 - **Install statusline** (Act now, or `--install-statusline`) adds a `statusLine` entry to
   `~/.claude/settings.json`, keeping a `.finops-backup` copy. It won't replace a statusline you

package/finops/api.py

@@ -433,7 +433,7 @@ class Handler(BaseHTTPRequestHandler):
         return self.send_json({"error": "unknown route"}, 404)
 
     def session_action(self, path):
-        """POST /api/live/<pid>/<interrupt|close|kill|compact|handover>.
+        """POST /api/live/<pid>/<interrupt|close|kill|compact|handover|rename>.
 
         Guarded against cross-site requests: a custom header can't be sent by another
         origin without a CORS preflight (which this server never approves), and any
@@ -451,7 +451,7 @@ class Handler(BaseHTTPRequestHandler):
         agent = (self._payload or {}).get("agent") or "claude"
         if agent != "claude":
             from .procs import act_agent
-            if parts[3] in ("handover", "compact"):
+            if parts[3] in ("handover", "compact", "rename"):
                 return self.send_json({"ok": False,
                                        "error": f"{parts[3].capitalize()} is only available for Claude Code."})
             return self.send_json(act_agent(int(parts[2]), parts[3], agent))
@@ -461,6 +461,9 @@ class Handler(BaseHTTPRequestHandler):
         if parts[3] == "compact":
             from .procs import compact
             return self.send_json(compact(int(parts[2]), self._payload))
+        if parts[3] == "rename":
+            from .procs import rename
+            return self.send_json(rename(int(parts[2]), self._payload))
         return self.send_json(act(int(parts[2]), parts[3]))
 
     def do_GET(self):
@@ -590,6 +593,9 @@ class Handler(BaseHTTPRequestHandler):
                 if not want or any(x != "claude" for x in want) else []
             rows = sorted(claude + others, key=lambda x: -(x.get("context") or 0))
             return self.send_json({"sessions": rows, "actions": list(ACTIONS)})
+        if route.startswith("session_prompts/"):
+            from .procs import session_prompts
+            return self.send_json(session_prompts(_session_transcript(route[len("session_prompts/"):])))
         if route.startswith("guard/session/"):
             return self.send_json(_session_limit_status(a, route[len("guard/session/"):]))
         if route == "subagents":

package/finops/procs.py

@@ -71,6 +71,12 @@ def _is_claude(p):
     return base in ("claude", "claude.exe", "claude.cmd") or cmd.endswith("/claude")
 
 
+def _same_start(reg, p):
+    """True unless the registry's procStart names a different start time than ps reports.
+    Whitespace is normalised: the registry pads single-digit days ("Oct  9"), ps output is re-joined ("Oct 9")."""
+    return not reg.get("procStart") or reg["procStart"].split() == p["lstart"].split()
+
+
 def _ancestors(pid, procs):
     seen = set()
     while pid in procs and pid not in seen and pid > 1:
@@ -128,8 +134,7 @@ def list_sessions(pricing):
             continue
         pid = reg.get("pid")
         p = procs.get(pid)
-        alive = bool(p) and _is_claude(p) and (
-            not reg.get("procStart") or reg["procStart"] == p["lstart"])
+        alive = bool(p) and _is_claude(p) and _same_start(reg, p)
         if not alive:
             continue
         st = _transcript_stats(reg.get("sessionId"), pricing)
@@ -160,9 +165,14 @@ def act(pid, action):
     p = procs.get(pid)
     if not p or not _is_claude(p):
         return {"ok": False, "error": "Process is no longer running."}
-    if reg.get("procStart") and reg["procStart"] != p["lstart"]:
+    if not _same_start(reg, p):
         return {"ok": False, "error": "PID was reused by another process; refusing."}
     sig, msg = ACTIONS[action]
+    if action == "interrupt":
+        pane = _herdr_pane(pid)
+        if pane and subprocess.run(["herdr", "pane", "send-keys", pane["pane_id"], "esc"],
+                                   capture_output=True, timeout=10).returncode == 0:
+            return {"ok": True, "message": "Pressed Esc in that session's herdr pane: the current turn stops."}
     try:
         os.kill(pid, sig)
     except ProcessLookupError:
@@ -444,11 +454,19 @@ def _render_brief(reg, b, task=None, part=None):
     return "\n".join(L)
 
 
-def _launch_terminal(cwd, prompt_path):
-    """Open a new Terminal window running a fresh `claude` seeded with the brief."""
+def _launch_terminal(cwd, prompt_path, herdr_pane=None):
+    """Open a new Terminal window running a fresh `claude` seeded with the brief.
+    herdr_pane: the old session's herdr pane; the new session opens as a tab next to it."""
     q = lambda s: "'" + s.replace("'", "'\\''") + "'"
     seed = f"Read the handover brief at {prompt_path} and continue from it."
     cmd = f"cd {q(cwd)} && claude {q(seed)}"
+    if herdr_pane:
+        tab = _herdr("tab", "create", "--workspace", herdr_pane.get("workspace_id") or "",
+                     "--cwd", cwd, "--label", "handover", "--focus")
+        new = (tab.get("root_pane") or {}).get("pane_id")
+        if new and subprocess.run(["herdr", "pane", "run", new, cmd],
+                                  capture_output=True, timeout=10).returncode == 0:
+            return True, ""
     if sys.platform == "darwin":
         osa = 'tell application "Terminal"\nactivate\ndo script ' + json.dumps(cmd) + "\nend tell"
         r = subprocess.run(["osascript", "-e", osa], capture_output=True, text=True)
@@ -484,13 +502,14 @@ def handover(pid, opts):
     stamp = time.strftime("%Y%m%d-%H%M%S")
     os.makedirs(HANDOFFS, exist_ok=True)
     out, jobs = [], tasks or [None]
+    pane = _herdr_pane(pid) if opts.get("launch", True) else None
     for i, t in enumerate(jobs, 1):
         path = os.path.join(HANDOFFS, f"{stamp}-{reg.get('sessionId', 'x')[:8]}-{i}.md")
         with open(path, "w") as fh:
             fh.write(_render_brief(reg, b, t, f"{i} of {len(jobs)}" if len(jobs) > 1 else None))
         item = {"brief": path, "task": t, "launched": False}
         if opts.get("launch", True):
-            item["launched"], err = _launch_terminal(reg.get("cwd") or HOME, path)
+            item["launched"], err = _launch_terminal(reg.get("cwd") or HOME, path, pane)
             if err:
                 item["error"] = err
         out.append(item)
@@ -507,7 +526,7 @@ def handover(pid, opts):
 # /compact is typed *into* the running session — there is no signal for it. Nothing
 # can write to another process's terminal directly (TIOCSTI is off on macOS and on
 # modern Linux), so the keystrokes are handed to whatever owns that terminal:
-# tmux if the session runs inside one, else Terminal.app or iTerm2 via
+# tmux or herdr if the session runs inside one, else Terminal.app or iTerm2 via
 # AppleScript, else Windows Terminal/console via SendKeys. When none of those owns
 # it, the UI falls back to copying the command for you to paste.
 
@@ -553,6 +572,44 @@ def _send_tmux(tty, pid, text):
     return False, ""
 
 
+def _herdr(*args):
+    """Run a herdr CLI call and return its `result` ({} on any failure)."""
+    try:
+        r = subprocess.run(["herdr", *args], capture_output=True, text=True, timeout=10)
+        return (json.loads(r.stdout).get("result") or {}) if r.returncode == 0 else {}
+    except (OSError, ValueError, subprocess.TimeoutExpired):
+        return {}
+
+
+def _herdr_pane(pid):
+    """The herdr pane (terminal workspace for AI agents) whose processes include this
+    session, or None when herdr isn't installed or the session runs elsewhere."""
+    if not shutil.which("herdr"):
+        return None
+    mine = _ancestors(pid, _ps()) | {pid}
+    for pane in _herdr("pane", "list").get("panes") or []:
+        if not pane.get("pane_id"):
+            continue
+        info = _herdr("pane", "process-info", "--pane", pane["pane_id"]).get("process_info") or {}
+        pids = {fp.get("pid") for fp in info.get("foreground_processes") or []} | {info.get("shell_pid")}
+        if pid in pids or info.get("shell_pid") in mine:
+            return pane
+    return None
+
+
+def _send_herdr(pid, text):
+    """herdr: type the text and Enter into the session's pane."""
+    pane = _herdr_pane(pid)
+    if not pane:
+        return False, ""
+    try:
+        r = subprocess.run(["herdr", "pane", "run", pane["pane_id"], text],
+                           capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.TimeoutExpired):
+        return False, ""
+    return (True, "herdr") if r.returncode == 0 else (False, (r.stderr or "").strip())
+
+
 def _send_macos(tty, text):
     """Terminal.app / iTerm2 both expose each tab's tty, so the right one is addressable."""
     if sys.platform != "darwin" or not tty:
@@ -642,12 +699,13 @@ def compact(pid, opts=None):
     p = _ps().get(pid)
     if not p or not _is_claude(p):
         return {"ok": False, "error": "Process is no longer running.", "copy": text}
-    if reg.get("procStart") and reg["procStart"] != p["lstart"]:
+    if not _same_start(reg, p):
         return {"ok": False, "error": "PID was reused by another process; refusing.", "copy": text}
 
     tty = _tty_of(pid)
     hint = ""
     for send in (lambda: _send_tmux(tty, pid, text),
+                 lambda: _send_herdr(pid, text),
                  lambda: _send_macos(tty, text),
                  lambda: _send_windows(pid, text)):
         ok, info = send()
@@ -661,3 +719,55 @@ def compact(pid, opts=None):
     return {"ok": False, "sent": False, "copy": text,
             "error": (hint or "Couldn't reach that session's terminal") +
                      f" — `{text}` is on your clipboard; paste it in that window."}
+
+
+def rename(pid, opts=None):
+    """Type `/rename <name>` into a running Claude Code session's terminal, so Claude Code
+    saves the name itself (registry and transcript), exactly as if you typed it there.
+
+    opts: name – the new name (one line, at most 80 characters)
+    """
+    name = " ".join("".join(c if c.isprintable() else " "
+                            for c in str((opts or {}).get("name") or "")).split())[:80]
+    if not name:
+        return {"ok": False, "error": "Type a name first."}
+    text = f"/rename {name}"
+    try:
+        with open(os.path.join(REG, f"{pid}.json")) as fh:
+            reg = json.load(fh)
+    except (OSError, ValueError):
+        return {"ok": False, "error": "Not a registered Claude Code session.", "copy": text}
+    p = _ps().get(pid)
+    if not p or not _is_claude(p):
+        return {"ok": False, "error": "Process is no longer running.", "copy": text}
+    if not _same_start(reg, p):
+        return {"ok": False, "error": "PID was reused by another process; refusing.", "copy": text}
+
+    tty = _tty_of(pid)
+    hint = ""
+    for send in (lambda: _send_tmux(tty, pid, text),
+                 lambda: _send_herdr(pid, text),
+                 lambda: _send_macos(tty, text),
+                 lambda: _send_windows(pid, text)):
+        ok, info = send()
+        if ok:
+            pane = _herdr_pane(pid) if info == "herdr" else None
+            if pane:   # herdr's agents sidebar keeps its own label; name it the same
+                _herdr("agent", "rename", pane["pane_id"], name)
+            return {"ok": True, "message": f"Sent `{text}` to the session"
+                                           f"{f' via {info}' if info else ''}. "
+                                           "The new name shows here once that session takes it.",
+                    "sent": True, "copy": text, "name": name}
+        if info and not hint:
+            hint = info
+    return {"ok": False, "sent": False, "copy": text,
+            "error": (hint or "Couldn't reach that session's terminal") +
+                     f" — `{text}` is on your clipboard; paste it in that window."}
+
+
+def session_prompts(fp, n=5):
+    """The first prompt and the last few, so you can tell which session is which."""
+    b = brief_from_transcript(fp)
+    recent = b["recent"][1:] if b["turns"] <= 6 else b["recent"]
+    return {"first": _clip(b["goal"], 1000), "recent": [_clip(t, 1000) for t in recent[-n:]],
+            "turns": b["turns"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Local FinOps dashboard for Claude Code: what you used, what it cost, why it cost that much, and what to change. Reads your own transcripts, no API key, no data leaves the machine.",
   "bin": {
     "claude-finops": "bin/claude-finops.js"

package/web/app.js

@@ -2107,6 +2107,21 @@ async function drawLimit(box, x, i) {
   box.querySelector('[data-lim-off]')?.addEventListener('click', () => send({off: true}, 'The guard is off for this conversation.'));
 }
 
+// The Prompts panel: the session's first prompt and its latest few, so you can tell sessions apart.
+async function drawPrompts(box, sid) {
+  box.innerHTML = '<div class="note">Reading prompts…</div>';
+  let d;
+  try {
+    const r = await fetch(`/api/session_prompts/${encodeURIComponent(sid)}`);
+    d = await r.json();
+    if (!r.ok) throw new Error(d.error || 'Could not read this session.');
+  } catch (e) { box.innerHTML = `<div class="live-msg err">${esc(e.message)}</div>`; return; }
+  if (!d.turns) { box.innerHTML = '<div class="note">No prompts yet.</div>'; return; }
+  const one = t => `<div class="dt prompt-txt">${esc(pt(t))}</div>`;
+  box.innerHTML = `<div class="note"><b>First prompt</b> · ${fmtInt(d.turns)} prompt${d.turns === 1 ? '' : 's'} in all</div>${one(d.first)}
+    ${d.recent.length ? `<div class="note"><b>Latest prompt${d.recent.length === 1 ? '' : 's'}</b> (newest last)</div>${d.recent.map(one).join('')}` : ''}`;
+}
+
 VIEWS.live = async (page) => {
   const [res, usage0] = await Promise.all([
     fetch('/api/live?agents=' + encodeURIComponent(S.filter.agents.join(','))).then(r => r.json()),   // never cached: always live
@@ -2129,7 +2144,7 @@ VIEWS.live = async (page) => {
     </div>
     <div class="note"><b>Idle sessions don't use tokens</b>; they only cost again when you send the next message,
       which re-reads their whole context. <b>Interrupt</b> stops the current turn (like Esc).
-      <b>Compact</b> types <code>/compact</code> into that session's terminal (tmux, Terminal.app, iTerm2 or
+      <b>Compact</b> types <code>/compact</code> into that session's terminal (tmux, herdr, Terminal.app, iTerm2 or
       Windows console; anywhere else it lands on your clipboard to paste).
       <b>Close</b> exits the session cleanly; copy its resume command to bring it back.
       <b>Force kill</b> is for a session that won't close. Each button asks you to click twice.
@@ -2140,7 +2155,7 @@ VIEWS.live = async (page) => {
       <div class="item sev-${sevOf(x)}" data-i="${i}">
         <div class="hd">${x.status === 'busy' ? '<span class="live-dot"></span>' : '<span class="idle-dot"></span>'}
           <span class="pill">${esc(agentName(x.agent))}</span>
-          ${esc((!MASKED && x.name) || shortId(x.session_id))} <span class="note">· ${esc(x.project)}${x.pid ? ` · pid ${x.pid}` : ''}${x.model ? ` · ${esc(x.model)}` : ''}</span>
+          <span class="sname">${esc((!MASKED && x.name) || shortId(x.session_id))}</span> <span class="note">· ${esc(x.project)}${x.pid ? ` · pid ${x.pid}` : ''}${x.model ? ` · ${esc(x.model)}` : ''}</span>
           ${x.hosts_dashboard ? '<span class="status high">runs this dashboard</span>' : ''}
           ${x.agent === 'claude' ? limitBadge(x.session_id) : ''}
           <span class="spacer"></span>
@@ -2159,6 +2174,8 @@ VIEWS.live = async (page) => {
           ${x.resume ? `<button class="act ghost" data-copy="${esc(x.resume)}">Copy resume command</button>` : ''}
           ${x.agent === 'claude' ? '<button class="act ghost" data-ho="1">' + I('handover') + ' Hand over / split</button>' : ''}
           ${x.agent === 'claude' && x.session_id ? '<button class="act ghost" data-lim="1">' + I('gauge') + ' Set limit</button>' : ''}
+          ${x.agent === 'claude' && x.session_id ? '<button class="act ghost" data-pr="1">' + I('message') + ' Prompts</button>' : ''}
+          ${x.agent === 'claude' && x.signalable ? '<button class="act ghost" data-rn="1">' + I('tag') + ' Rename</button>' : ''}
           <span class="live-msg"></span>
         </div>
         ${x.agent !== 'claude' ? '' : `<div class="handover" hidden>
@@ -2174,6 +2191,15 @@ VIEWS.live = async (page) => {
           <div class="ho-out note"></div>
         </div>`}
         ${x.agent === 'claude' && x.session_id ? `<div class="handover limitbox" hidden></div>` : ''}
+        ${x.agent === 'claude' && x.session_id ? `<div class="handover promptbox" hidden></div>` : ''}
+        ${x.agent === 'claude' && x.signalable ? `<div class="handover renamebox" hidden>
+          <div class="dt">Types <code>/rename &lt;name&gt;</code> into that session's terminal, so Claude Code saves the
+            name itself (in herdr, the agents sidebar gets the same name). If the terminal can't be reached, the command lands on your clipboard to paste.</div>
+          <div class="live-actions">
+            <input type="text" class="rn-in" maxlength="80" placeholder="New name for this session" value="${esc(MASKED ? '' : (x.name || ''))}">
+            <button class="act rn-go">Rename</button>
+            <span class="live-msg rn-msg" role="status"></span>
+          </div></div>` : ''}
       </div>`).join('') || `<div class="empty">No ${esc(agentWord())} sessions are running</div>`}</div>`;
   $('#live-refresh', page).onclick = () => render();
   const ub = $('#usage-refresh', page);
@@ -2207,13 +2233,37 @@ VIEWS.live = async (page) => {
       ho.querySelector('.ho-go').onclick = e => runHandover(true, e.currentTarget);
       ho.querySelector('.ho-brief').onclick = e => runHandover(false, e.currentTarget);
     }
-    row.querySelectorAll('button.act:not(.ho-go):not(.ho-brief)').forEach(b => {
+    const rn = row.querySelector('.renamebox');
+    if (rn) {
+      const inp = rn.querySelector('.rn-in'), go = rn.querySelector('.rn-go'), rmsg = rn.querySelector('.rn-msg');
+      const doRename = async () => {
+        if (!inp.value.trim()) { rmsg.className = 'live-msg rn-msg err'; rmsg.textContent = 'Type a name first.'; return; }
+        go.disabled = true; go.textContent = 'Working…';
+        try {
+          const r = await sessionAction(pid, 'rename', {name: inp.value});
+          if (!r.ok && r.copy) { try { await navigator.clipboard.writeText(r.copy); } catch {} }
+          rmsg.className = 'live-msg rn-msg ' + (r.ok ? 'ok' : 'err');
+          rmsg.textContent = r.ok ? r.message : `Failed: ${r.error}`;
+          if (r.ok && !MASKED) row.querySelector('.sname').textContent = r.name;
+        } catch (e) { rmsg.className = 'live-msg rn-msg err'; rmsg.textContent = 'Failed: ' + e.message; }
+        go.disabled = false; go.textContent = 'Rename';
+      };
+      go.onclick = doRename;
+      inp.onkeydown = e => { if (e.key === 'Enter') doRename(); };
+    }
+    row.querySelectorAll('button.act:not(.ho-go):not(.ho-brief):not(.rn-go)').forEach(b => {
       if (b.dataset.ho) { b.onclick = () => { ho.hidden = !ho.hidden; if (!ho.hidden) ta.focus(); }; return; }
       if (b.dataset.lim) {
         const box = row.querySelector('.limitbox');
         b.onclick = () => { box.hidden = !box.hidden; if (!box.hidden) drawLimit(box, x, +row.dataset.i); };
         return;
       }
+      if (b.dataset.pr) {
+        const box = row.querySelector('.promptbox');
+        b.onclick = () => { box.hidden = !box.hidden; if (!box.hidden) drawPrompts(box, x.session_id); };
+        return;
+      }
+      if (b.dataset.rn) { b.onclick = () => { rn.hidden = !rn.hidden; if (!rn.hidden) rn.querySelector('.rn-in').focus(); }; return; }
       if (b.dataset.copy) { b.onclick = async () => { try { await navigator.clipboard.writeText(b.dataset.copy); msg.textContent = 'Copied'; } catch { msg.textContent = b.dataset.copy; } }; return; }
       const label = b.textContent;
       b.onclick = async () => {
@@ -4315,7 +4365,7 @@ const TOURS = {
   live: [
     {el: 'kpis', t: 'Running now', see: 'Sessions running right now, which are working (spending) at this moment, the largest live context and what live sessions have spent.', get: 'What is costing you money this second.', act: 'Only <b>working</b> sessions consume tokens; idle ones cost again on your next message.'},
     {el: '#live-refresh', t: 'Refresh & the rules', see: 'The note explains what Interrupt, Close and Force kill do, and how non-Claude agents are detected.', get: 'Confidence before you stop something.', act: `Click <b>${I('reload')} Refresh</b> for the latest state.`},
-    {el: '.item[data-i]', t: 'A session', see: 'Agent, project, context size, steps, cost and last activity, plus advice when a session gets heavy.', get: 'Control over sessions that are quietly growing expensive.', act: 'Interrupt, Close or Force kill it (each needs two clicks), copy its resume command, or <b>Hand over</b> a Claude session to a fresh one.'}],
+    {el: '.item[data-i]', t: 'A session', see: 'Agent, project, context size, steps, cost and last activity, plus advice when a session gets heavy.', get: 'Control over sessions that are quietly growing expensive.', act: 'Interrupt, Close or Force kill it (each needs two clicks), copy its resume command, <b>Hand over</b> a Claude session to a fresh one, see its <b>Prompts</b> or <b>Rename</b> it.'}],
   scorecard: [
     {el: 'card:AI FinOps Score', t: 'Your score', see: 'The overall score with a component breakdown: cache use, model mix, waste and budget.', get: 'Where your habits are strong and where they cost money.', act: 'Hover a component to see how it is calculated.'},
     {el: 'card:What is good', t: 'What is good', see: 'The components you already score well on.', get: 'The habits worth keeping.', act: 'Keep these when you change your setup.'},

package/web/styles.css

@@ -497,6 +497,8 @@ table.tbl .sub { font-size:10.5px; color:var(--muted); }
   border: 1px solid var(--border); background: transparent; color: inherit; resize: vertical; }
 .handover .ho-out { display: grid; gap: 4px; }
 .handover .ho-out code { word-break: break-all; }
+.handover .prompt-txt { white-space: pre-wrap; word-break: break-word; max-height: 160px; overflow: auto; padding: 6px 8px; border-radius: 6px; background: var(--surface-2); }
+.handover .rn-in { flex: 1; min-width: 180px; font: inherit; font-size: 12.5px; padding: 6px 8px; border-radius: 6px; border: 1px solid var(--border); background: transparent; color: inherit; }
 
 /* ---------- walkthrough ---------- */
 #tour { position: fixed; inset: 0; z-index: 1000; pointer-events: none; }