The terminal learns where one command ends, and can be dragged wider

"The last command and its output" was not something the panel could honestly
offer. sendToChat took the last forty rows of the screen buffer, hard-wrapped at
the terminal's width with no way to tell a wrap from a newline -- its own comment
said so. So bash and zsh are given the OSC 133 markers VS Code and WezTerm use,
and Copy, Send and an Auto toggle are built on those.

The integration is written by the PTY command string itself, with printf. sshd
runs that string through $SHELL -c, so it can case on the shell's own name and
needs no probe, no second channel and no writable home. Passing it through the
environment does not work -- every distribution ships AcceptEnv LANG LC_*, so
anything else is dropped silently -- and feeding `source ...` in as keystrokes
races a slow .zshrc, echoes into the scrollback and lands in shell history.

Nothing needs hiding, which is the point of choosing it: the setup runs before
the shell exists and never writes to the PTY's input side, so there is nothing
to echo and no fan-out gate to build.

Two things were wrong in the first version and both were found by running it
against real shells rather than the fake one. bash: the DEBUG trap fires before
every simple command *including each one inside PROMPT_COMMAND*, so $? read from
there is whatever ran a moment ago -- every command reported success. The status
is captured in the trap now, which also removes the two-entry PROMPT_COMMAND
dance entirely. zsh: $ZDOTDIR is already ours by the time .zshenv runs, so the
shims were sourcing themselves and none of the user's configuration loaded; the
original is passed on the exec line.

Parsing is server-side. The `behind` path resets the terminal and replays a
truncated scrollback, so a client parser routinely sees a finish with no start;
two tabs share one shell and can disagree; and what comes out of this ends up
inside a prompt, so deriving it here leaves nothing to disbelieve. The bytes are
fanned out unchanged -- xterm consumes an OSC it has no handler for.

Output is bounded head and tail, 48KB and 16KB: a build that fails ten megabytes
in has the invocation at the top and the error at the bottom. Carriage returns
collapse to the last state of each line, which is the difference between a
usable prompt and two megabytes of spinner. The fence is sized to its content,
because output containing three backticks would otherwise break out and read as
prose.

Any shell that is not bash or zsh starts exactly as it did before. The buttons
then scrape the screen and say so, and Auto is disabled rather than degraded:
forty arbitrary lines on every message is worse than nothing.

Also a generic [data-resize] handle, keyboard included, persisted the way the
theme is. The inspector and sidebar can have it whenever they want it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/lembas/api/terminal.py

@@ -27,8 +27,9 @@ import json
 import logging
 from urllib.parse import urlsplit
 
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect, status
 
+from lembas.api.deps import Db, RequiredUser
 from lembas.db.models import KIND_AGENT, Chat
 from lembas.db.session import session_scope
 from lembas.security import permissions
@@ -111,6 +112,7 @@ def _prepare(db, user, chat_id: str) -> tuple[str, dict]:
         "idle_timeout": float(values["terminal_idle_timeout"]),
         "max_sessions": int(values["terminal_max_sessions"]),
         "max_per_user": int(values["terminal_max_per_user"]),
+        "integrate": bool(values.get("terminal_integration", True)),
     }
 
 
@@ -148,6 +150,13 @@ async def terminal_socket(
         await _refuse(websocket, "The shell could not be started.")
         return
 
+    # Shaping a frame is this layer's job, not the session's; the session only
+    # knows it finished something. Reassigned per socket and harmless: every
+    # socket on this session would build the identical frame.
+    session.on_command = lambda found: session.announce(
+        json.dumps({"t": "command", "command": _command_frame(found)})
+    )
+
     viewer = session.attach(cols, rows)
     await websocket.send_text(
         json.dumps(
@@ -160,6 +169,10 @@ async def terminal_socket(
                 # Two tabs share one shell, and a size neither of them chose is
                 # otherwise a mystery.
                 "shared": len(session.viewers) > 1,
+                # Whether this shell will tell us where commands begin and end,
+                # which is what the Copy and Send buttons are made of.
+                "integration": session.integration,
+                "last": _command_frame(session.latest()),
             }
         )
     )
@@ -182,6 +195,63 @@ async def terminal_socket(
         session.detach(viewer)
 
 
+@router.get("/{chat_id}/terminal/last")
+async def last_command(db: Db, user: RequiredUser, chat_id: str) -> dict:
+    """The last command and its output, rendered ready to paste.
+
+    The *server* renders the text, so Copy and Send are a fetch and a
+    clipboard write with no formatting logic in the browser -- and the block a
+    model eventually reads exists in exactly one place. The panel's own screen
+    buffer could not produce it anyway: it holds what is on screen, hard-wrapped
+    at the terminal's width, with no way to tell a wrap from a newline.
+    """
+    chat = db.get(Chat, chat_id)
+    if chat is None or chat.user_id != user.id:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "That chat no longer exists.")
+    if not permissions.has(db, user, "agent.terminal"):
+        raise HTTPException(status.HTTP_403_FORBIDDEN, "You cannot open a terminal.")
+
+    session = terminal_service.get(chat_id)
+    found = session.latest() if session is not None else None
+    if session is None or found is None:
+        return {
+            "ok": False,
+            "message": "Nothing has been run in this shell yet."
+            if session is not None
+            else "This terminal is not open.",
+        }
+
+    return {
+        "ok": True,
+        "command": found.command,
+        "cwd": found.cwd,
+        "exit": found.exit_status,
+        "running": found.running,
+        "summary": found.summary(),
+        "text": found.as_text(label=session.label),
+    }
+
+
+def _command_frame(found) -> dict | None:
+    """A finished command, small enough to push at every viewer.
+
+    Tens of bytes, and deliberately *not* the output: a 64KB text frame would
+    compete with PTY bytes on the one path that has to stay responsive, and the
+    two buttons are pressed by a person, where a request is the natural shape.
+    """
+    if found is None:
+        return None
+    return {
+        "seq": found.seq,
+        "command": found.command,
+        "cwd": found.cwd,
+        "exit": found.exit_status,
+        "running": found.running,
+        "ms": found.duration_ms,
+        "summary": found.summary(),
+    }
+
+
 async def _to_browser(websocket: WebSocket, session, viewer) -> None:
     """Everything the shell says, plus the one frame that says it stopped."""
     while True:
@@ -198,6 +268,11 @@ async def _to_browser(websocket: WebSocket, session, viewer) -> None:
             with contextlib.suppress(Exception):
                 await websocket.send_text(json.dumps(payload))
             return
+        # A string in the queue is a control frame that had to keep its place
+        # in the stream -- see `Session.announce`.
+        if isinstance(chunk, str):
+            await websocket.send_text(chunk)
+            continue
         await websocket.send_bytes(chunk)