Files, open beside the conversation

A third side panel, built the way the terminal is and filled the way the
inspector is: tabs holding open files. Project files over SFTP in an agent
chat; notes, skills, knowledge documents, this chat's text attachments and its
own scratch document everywhere. Read with pygments, edited in a plain
textarea, saved with a conflict check.

A bug found on the way in, and the reason this needed its own read path.
`ssh.read_file` ends in `clean_output`, which strips ANSI escapes and decodes
with errors="replace" -- right for the output of a command, and fatal for an
editor: open a file containing an escape byte, press Save, and you have
silently rewritten it with the escapes gone and every undecodable byte replaced
by U+FFFD. `read_text`/`write_text` decode strictly, report binary rather than
mangling it, carry an mtime:size token for a file that moved underneath, and
refuse an oversize write rather than truncating -- `write_file` truncates
because a model is told how many bytes it wrote, and somebody pressing Save is
not. The model-facing pair is untouched: what it returns is a contract a model
has been shown. A truncated read opens read-only for the mirror-image reason.

Six sources go through one dispatch table, for the reason tool_labels.py is a
table: six independently written permission checks is how one ends up written
slightly differently, and that failure looks like editing somebody else's note.

A save on a project file bypasses agent/policy.py, which makes it the fourth
documented exception to "the modes do not govern the keyboard" and the first
that writes. Same argument as the terminal panel -- whoever owns the credential
could write the file with scp -- but the consequence is larger and is now said
out loud rather than left to be inferred.

The model opens tabs from the file tools it was already calling, so no new
schema and no tokens. It never brings one to the front: an agent reads forty
files in a long reply, and taking the screen each time would drag somebody
through all of them and lose any edit in progress. Only the strip is streamed,
guarded on truthiness so the frame can never blank itself -- an empty one would
close every open tab, the approval card you could press twice with the sign
reversed. Both halves are settled on the server, which is why canvas.js needs
no guard against a swap at all.

No vendored editor. CodeMirror 6 needs a bundler, which is hard rule 1;
CodeMirror 5 would be a larger payload than xterm on every page, and xterm is
the one heavy dependency precisely because it loads only where it can be used.
So: server-rendered highlighting for reading, a textarea for writing, and the
panel says there is no colour while you type rather than pretending.

Also here: a scratch document per chat, with `scratch_write` at RISK_READ on
plan_update's argument, and a test pinning the three numbers that decide a
panel's width -- LAYOUT_BOUNDS drops an unknown variable silently, so a panel
missing from it has a drag handle that works and forgets.

Driven under a DOM stub and against the running application.

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

src/lembas/api/canvas.py

@@ -0,0 +1,198 @@
+"""The canvas panel: open a file, read it, change it, save it.
+
+Every route answers with an HTML fragment, errors included. An exception page
+swapped into a side panel is a blank side panel, and a panel that goes blank
+tells somebody nothing about why.
+
+`GET` never moves the active tab. There is no CSRF token in this application and
+the session cookie is SameSite Lax, so a state-changing GET is a link somebody
+can be made to follow -- and one of the things a tab can be is a file on
+somebody's server.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Form, HTTPException, Request, Response, status
+from sqlalchemy.orm import Session as DBSession
+
+from lembas.api.deps import Db, RequiredUser
+from lembas.db.models import Chat, User
+from lembas.services import canvas as canvas_service
+from lembas.services import generation as generation_service
+from lembas.services.agent.base import Conflict
+from lembas.services.markdown import highlight_code, render_markdown
+from lembas.web.templating import templates
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/chats", tags=["canvas"])
+
+
+def _owned_chat(db: DBSession, chat_id: str, user_id: str) -> Chat:
+    """404 rather than 403 for somebody else's chat: whether it exists at all is
+    not this account's business."""
+    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.")
+    return chat
+
+
+async def _panel(
+    request: Request,
+    db: DBSession,
+    user: User,
+    chat: Chat,
+    *,
+    key: str = "",
+    message: str = "",
+    conflict: canvas_service.Doc | None = None,
+    mine: str = "",
+) -> Response:
+    """The strip and whichever tab is in front, as one fragment.
+
+    Both together, always. Rendering only the body would leave the strip showing
+    a tab that is no longer there after a close, and rendering only the strip
+    would leave the previous file on screen after a switch.
+    """
+    wanted = key or canvas_service.active_of(chat)
+    doc: canvas_service.Doc | None = None
+    error = message
+    if wanted and not error:
+        try:
+            doc = await canvas_service.load(db, user, chat, wanted)
+        except canvas_service.Refused as exc:
+            error = str(exc)
+        except Exception:  # pragma: no cover - a machine going away mid-request
+            log.exception("canvas could not open %s", wanted)
+            error = "That could not be opened."
+
+    body = ""
+    if doc is not None and doc.text:
+        # The one `|safe` in this panel, and it is safe because pygments escapes
+        # what it is given. Markdown goes through render_markdown, the single
+        # path in this application allowed to emit HTML. Everything else -- the
+        # editor's contents, the titles, the paths -- is escaped by Jinja.
+        body = render_markdown(doc.text) if doc.markdown else highlight_code(doc.text, doc.language)
+
+    return templates.TemplateResponse(
+        request,
+        "chat/_canvas_inner.html",
+        {
+            "user": user,
+            "chat": chat,
+            "tabs": canvas_service.tabs_of(chat),
+            "active": wanted,
+            "doc": doc,
+            "rendered": body,
+            "error": error,
+            "conflict": conflict,
+            "mine": mine,
+            "canvas_agent": canvas_service.agent_ready(db, user, chat) is not None,
+        },
+    )
+
+
+@router.get("/{chat_id}/canvas")
+async def show(request: Request, db: Db, user: RequiredUser, chat_id: str, key: str = ""):
+    """Whatever is in front, or the tab named by `?key=`.
+
+    Read-only in every sense: a `?key=` that is not open does not become open,
+    it is simply shown. Opening is a POST.
+    """
+    chat = _owned_chat(db, chat_id, user.id)
+    return await _panel(request, db, user, chat, key=key)
+
+
+@router.post("/{chat_id}/canvas/tabs")
+async def open_tab(
+    request: Request,
+    db: Db,
+    user: RequiredUser,
+    chat_id: str,
+    key: str = Form(...),
+    title: str = Form(""),
+):
+    """Open a file, or bring an already-open one to the front.
+
+    Idempotent, because opening what is already open is switching to it -- the
+    same reason `generation.ensure` is idempotent.
+    """
+    chat = _owned_chat(db, chat_id, user.id)
+
+    try:
+        doc = await canvas_service.load(db, user, chat, key)
+    except canvas_service.Refused as exc:
+        return await _panel(request, db, user, chat, message=str(exc))
+
+    state = canvas_service.open_tab(
+        dict(chat.canvas_json or {}),
+        {"key": doc.key, "title": title.strip() or doc.title, "source": doc.key.split(":")[0]},
+    )
+    # Reassigned rather than mutated: an in-place edit of a JSON column is not
+    # reliably detected as a change.
+    chat.canvas_json = state
+    db.commit()
+
+    # A reply running right now holds its own snapshot, seeded when it started.
+    # Without this the next frame it sends would contradict what was just
+    # swapped in -- the same reach into live state `request_stop` makes.
+    live = generation_service.running_for(chat.id)
+    if live is not None:
+        canvas_service.open_tab(live.canvas, {"key": doc.key, "title": doc.title})
+
+    return await _panel(request, db, user, chat, key=doc.key)
+
+
+@router.post("/{chat_id}/canvas/tabs/close")
+async def close_tab(
+    request: Request, db: Db, user: RequiredUser, chat_id: str, key: str = Form(...)
+):
+    chat = _owned_chat(db, chat_id, user.id)
+    chat.canvas_json = canvas_service.close_tab(dict(chat.canvas_json or {}), key)
+    db.commit()
+
+    live = generation_service.running_for(chat.id)
+    if live is not None:
+        canvas_service.close_tab(live.canvas, key)
+
+    return await _panel(request, db, user, chat)
+
+
+@router.post("/{chat_id}/canvas/save")
+async def save(
+    request: Request,
+    db: Db,
+    user: RequiredUser,
+    chat_id: str,
+    key: str = Form(...),
+    text: str = Form(""),
+    revision: str = Form(""),
+):
+    """Write it back.
+
+    A conflict comes back as a card, at 200, so htmx swaps it: the panel has to
+    be able to show Overwrite, Discard mine and Show what changed, and none of
+    those can be offered from an error status htmx will not render. Never save
+    silently over a change; never discard silently either.
+    """
+    chat = _owned_chat(db, chat_id, user.id)
+
+    try:
+        await canvas_service.save(db, user, chat, key, text, revision)
+    except Conflict:
+        try:
+            theirs = await canvas_service.load(db, user, chat, key)
+        except canvas_service.Refused as exc:
+            return await _panel(request, db, user, chat, key=key, message=str(exc))
+        return await _panel(request, db, user, chat, key=key, conflict=theirs, mine=text)
+    except canvas_service.Refused as exc:
+        return await _panel(request, db, user, chat, key=key, message=str(exc))
+    except Exception:  # pragma: no cover - the machine going away mid-write
+        log.exception("canvas could not save %s", key)
+        return await _panel(
+            request, db, user, chat, key=key, message="That could not be saved."
+        )
+
+    return await _panel(request, db, user, chat, key=key)

src/lembas/api/chats.py

@@ -8,6 +8,7 @@ import logging
 import time
 from collections.abc import AsyncIterator
 from datetime import UTC, datetime
+from types import SimpleNamespace
 
 from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
 from fastapi.responses import HTMLResponse, JSONResponse, Response, StreamingResponse
@@ -855,6 +856,25 @@ def _ask_html(chat_id: str, pending) -> str:
     )
 
 
+def _canvas_tabs(chat_id: str, state: dict) -> str:
+    """The canvas tab strip, as an out-of-band swap.
+
+    Out of band because it belongs to a panel, not to the bubble the stream is
+    writing into -- the same move the `done` frame already makes for the chat
+    title. Only the strip: pushing the file's contents on every version bump
+    would be a lot of bytes for nothing, and would overwrite a textarea somebody
+    is typing in. The active tab's body fetches itself once instead.
+    """
+    return templates.get_template("chat/_canvas_tabs.html").render(
+        {
+            "chat": SimpleNamespace(id=chat_id),
+            "tabs": state.get("tabs") or [],
+            "active": state.get("active") or "",
+            "oob": True,
+        }
+    )
+
+
 async def _follow(chat_id: str, message_id: str) -> AsyncIterator[str]:
     """Stream a generation that is running independently of this request.
 
@@ -881,6 +901,19 @@ async def _follow(chat_id: str, message_id: str) -> AsyncIterator[str]:
                     yield sse.event("tools", _tool_activity(generation.tool_events))
                 if generation.content:
                     yield sse.event("render", render_markdown(generation.text))
+                if generation.canvas.get("tabs"):
+                    # Guarded on truthiness, which puts this in the
+                    # reasoning/tools/render group and not the
+                    # metrics/status/ask one. Those three are sent even when
+                    # empty *because* each has to be able to clear itself; this
+                    # one must never be able to, since an empty canvas frame
+                    # would close every tab somebody had open. The card that
+                    # could be pressed twice, with the sign reversed.
+                    #
+                    # The whole strip each time, not a delta, so a follower
+                    # attaching mid-reply gets every tab the reply has touched
+                    # rather than the ones that happened to arrive after it.
+                    yield sse.event("canvas", _canvas_tabs(chat_id, generation.canvas))
                 yield sse.event("metrics", _metrics_html(generation))
                 yield sse.event("status", escape_text(generation.status))
                 yield sse.event("ask", _ask_html(chat_id, generation.pending))

src/lembas/api/files.py

@@ -19,7 +19,7 @@ from fastapi.responses import FileResponse
 from sqlalchemy import select
 
 from lembas.api.deps import Db, RequiredUser, require_permission
-from lembas.db.models import Attachment, Document, KnowledgeBase, Note
+from lembas.db.models import Attachment, Chat, Document, KnowledgeBase, Note
 from lembas.security import permissions
 from lembas.services import files as files_service
 from lembas.services import settings_store
@@ -189,6 +189,41 @@ async def attach_from_note(
     )
 
 
+@router.post("/from-scratch", dependencies=[Depends(require_permission("files.upload"))])
+async def attach_from_scratch(
+    request: Request, db: Db, user: RequiredUser, chat_id: str = Form("")
+) -> Response:
+    """Attach this chat's scratch document.
+
+    A copy, like every other attach path, and here the reason is at its
+    sharpest: the pad goes on being written after the message is sent, by the
+    person and by the model, and a transcript that changed underneath itself
+    every time either of them typed would be no record at all.
+    """
+    from lembas.services import scratch as scratch_service
+
+    chat = db.get(Chat, chat_id) if chat_id else None
+    if chat is None or chat.user_id != user.id:
+        return _not_available(request, "scratch document")
+
+    doc = scratch_service.get(db, chat)
+    if doc is None or not (doc.body or "").strip():
+        return _not_available(request, "scratch document")
+
+    return _chip(
+        request,
+        files_service.store_text(
+            db,
+            user_id=user.id,
+            chat_id=chat.id,
+            filename=f"{doc.title or 'scratch'}.md",
+            text=doc.body,
+            source_path=doc.title or "Scratch",
+            source_label="Scratch",
+        ),
+    )
+
+
 @router.post("/from-skill", dependencies=[Depends(require_permission("files.upload"))])
 async def attach_from_skill(
     request: Request, db: Db, user: RequiredUser, skill_id: str = Form(""), chat_id: str = Form("")

src/lembas/api/pages.py

@@ -11,6 +11,7 @@ from lembas.api.deps import Db, RequiredUser
 from lembas.db.models import KIND_CHAT, KINDS, Chat, Folder, KnowledgeBase, Message, User
 from lembas.security import permissions
 from lembas.services import audio as audio_service
+from lembas.services import canvas as canvas_service
 from lembas.services import chat as chat_service
 from lembas.services import compaction as compaction_service
 from lembas.services import settings_store
@@ -185,6 +186,16 @@ def _agent_context(db: DBSession, user: User, chat: Chat | None) -> dict:
             for m in agent_policy.MODES
         ],
         "terminal_enabled": _terminal_enabled(db, user, chat, current),
+        # Any chat that exists. Deliberately not gated the way the terminal is:
+        # half the canvas's sources -- notes, skills, this chat's attachments,
+        # its own scratch document -- need no machine at all, so the terminal's
+        # total gate would remove a working feature because one source is
+        # unavailable. Absent on the new-chat screen for the reason the scope
+        # menu is: there is no row yet to hang a tab on.
+        "canvas_enabled": chat is not None,
+        # And whether it may *also* reach project files. Re-derived server-side
+        # on every canvas request; this flag only decides what the panel offers.
+        "canvas_agent": canvas_service.agent_ready(db, user, chat) is not None,
     }
 
 

src/lembas/api/preferences.py

@@ -44,6 +44,7 @@ async def set_theme(db: Db, user: RequiredUser, theme: str = Body(..., embed=Tru
 # panel they cannot see to drag back.
 LAYOUT_BOUNDS = {
     "--terminal-width": (384, 2400),
+    "--canvas-width": (384, 2400),
     "--inspector-width": (280, 2400),
     "--sidebar-width": (200, 800),
 }