mulmoterminal 4.27.0 → 5.0.1

package/README.md

@@ -1641,6 +1641,20 @@ narrow and tall for one record you are discussing — and each position keeps it
   prompt history, codex's rollout), so a prompt sent mid-turn is there and text a skill
   injected is not. A `/clear` draws a line: the pane shows what you have asked *since*, the
   same way the header, the title and the last reply all stop describing the ended conversation.
+- **Conversation pane** — the enlarged cell's conversation, read as TURNS rather than as the
+  screen, from `GET /api/transcript/view`. A Claude cell runs on the alternate screen, so the
+  terminal keeps no scrollback worth scrolling; this reads the agent's own transcript instead,
+  and **scrolling up walks the session back to its first turn**, a page at a time.
+  - It **takes the terminal's place when you open it** — the one pane that does, because reading
+    is its whole subject. The expand button puts the terminal back beside it.
+  - **A frame per speaker**: what you asked in one, what the agent answered in another, named
+    ("You" / "Claude"). The reply is **rendered markdown** — headings, lists, tables, fenced
+    code — not the characters it is written with.
+  - **Tool traffic is folded away**, one line saying what ran (`Bash · Read`); click to open it.
+    It is most of a turn's bulk and almost none of what you came back to read.
+  - A **snapshot**, not a live tail — the terminal beside it is the live view — and the header's
+    reload fetches the newest turns again. Claude, Codex, Cursor and Copilot; an agent whose
+    conversation no reader here can read yet says so rather than showing an empty pane.
 - **Notifications** (🔔) — a toolbar bell with an unread badge and a dropdown of active
   notifications; click a row to jump to its session.
 - **Star MulmoTerminal** — a star button in the grid toolbar that stars the project on GitHub

package/common/codeBlocks.ts

@@ -55,9 +55,31 @@ const closes = (line: string, opener: string): boolean => {
   return !!fence && fence.run[0] === opener[0] && fence.run.length >= opener.length && fence.info.trim() === "";
 };
 
-export function fencedBlocks(markdown: string): FencedBlock[] {
+/** A run of prose, or one fenced block — the whole text, in order and with nothing dropped.
+ *
+ *  This is the ONE walk over the fences, and `fencedBlocks` below is it with the prose dropped. It
+ *  is not a second scanner: the two used to be separate loops over the same rules, which is two
+ *  places for a fence rule to drift.
+ *
+ *  It is deliberately not tied to any one reader. The transcript pane rendered its segments for a
+ *  while and now renders the reply as markdown instead (#2112); saying otherwise here sends the next
+ *  reader looking for a consumer that no longer exists (Claude review, round 1). */
+export type MarkdownSegment = { kind: "text"; text: string } | { kind: "code"; lang: string | null; body: string };
+
+/** The one walk over the fences. `fencedBlocks` is this with the prose dropped.
+ *
+ *  Prose runs are joined with the newlines they had, so a run's own blank lines survive; a segment
+ *  is emitted only when it has a line in it, so an input that opens with a fence does not lead with
+ *  an empty one. */
+export function markdownSegments(markdown: string): MarkdownSegment[] {
   const lines = markdown.split("\n");
-  const blocks: FencedBlock[] = [];
+  const segments: MarkdownSegment[] = [];
+  const prose: string[] = [];
+  const flushProse = (): void => {
+    if (prose.length === 0) return;
+    segments.push({ kind: "text", text: prose.join("\n") });
+    prose.length = 0;
+  };
   let i = 0;
   // Each line is read into a const before use: with noUncheckedIndexedAccess, `lines[i]` is
   // `string | undefined` even inside `i < lines.length`, and the loop condition is what actually
@@ -66,9 +88,11 @@ export function fencedBlocks(markdown: string): FencedBlock[] {
     const line = lines[i];
     const open = line === undefined ? null : fenceOf(line);
     if (!open) {
+      if (line !== undefined) prose.push(line);
       i++;
       continue;
     }
+    flushProse();
     const fence = open.run;
     const info = open.info.trim();
     const body: string[] = [];
@@ -78,9 +102,14 @@ export function fencedBlocks(markdown: string): FencedBlock[] {
       i++;
     }
     i++; // step over the closing fence (or past the end, for an unclosed block)
-    blocks.push({ lang: info ? (info.split(/\s+/)[0]?.toLowerCase() ?? null) : null, body: body.join("\n") });
+    segments.push({ kind: "code", lang: info ? (info.split(/\s+/)[0]?.toLowerCase() ?? null) : null, body: body.join("\n") });
   }
-  return blocks;
+  flushProse();
+  return segments;
+}
+
+export function fencedBlocks(markdown: string): FencedBlock[] {
+  return markdownSegments(markdown).flatMap((segment) => (segment.kind === "code" ? [{ lang: segment.lang, body: segment.body }] : []));
 }
 
 /** The block a reader means by "the code you just gave me": the last one. Null when the reply

package/common/transcriptView.ts

@@ -0,0 +1,78 @@
+// What a hosted agent's conversation looks like ON THE WIRE.
+//
+// In `common/` because both ends decide from it: the host folds an agent's JSONL (or copilot's
+// table) into these shapes in `server/session/transcript-view.ts`, and two clients render them —
+// the phone's terminal detail page over the remoteHost socket, and the browser's transcript pane
+// over `/api/transcript/view`. Mirroring the shape into `src/` would let one side gain a status the
+// other silently renders as nothing.
+//
+// The RULES that produce these — the turn boundary, the line budget, the tool-result cap — stay on
+// the server. This file is the vocabulary, not the folding.
+
+export type TranscriptRowKind = "user" | "assistant" | "tool" | "unknown";
+
+/** One content block, rendered.
+ *
+ *  `text` may itself contain newlines — an assistant answer is passed through whole, because the
+ *  wrapping belongs to the client's CSS and not to a host that cannot know its width.
+ *
+ *  `clipped` says THIS row's text was cut, which is a different fact from `TranscriptView.truncated`
+ *  (a whole turn was dropped). Naming them the same word would leave the client unable to decide
+ *  which mark to draw. */
+export interface TranscriptRow {
+  kind: TranscriptRowKind;
+  text: string;
+  clipped?: boolean;
+  /** This tool row is the CALL — the tool's name and the head of its arguments — rather than what
+   *  the tool answered (#2112).
+   *
+   *  Said by the host because only the host can say it: both halves arrive as `kind: "tool"`, and a
+   *  client telling them apart by shape ("short and single-line means a name") is guessing about
+   *  four agents' output at once. A pane that collapses tool traffic needs it to label the fold with
+   *  what RAN — the part a reader is looking for when they open it again. */
+  call?: boolean;
+}
+
+/** One exchange: a user prompt and everything that followed it.
+ *
+ *  `at` is the BOUNDARY record's own timestamp — the moment the turn started — or null when it is
+ *  not a string. Null rather than dropping the turn: a turn is worth more than its clock. */
+export interface TranscriptTurn {
+  at: string | null;
+  rows: TranscriptRow[];
+}
+
+/** What the host answers. A discriminated union rather than "readable: boolean": "no transcript
+ *  yet", "the conversation was ended with /clear" and "too big to find a turn in" are three
+ *  different things to tell a person, and one boolean collapses them into the same blank view. */
+export type TranscriptView =
+  | { status: "ok"; turns: TranscriptTurn[]; truncated: boolean }
+  | { status: "none" }
+  | { status: "cleared" }
+  | { status: "too-large" }
+  /** This session's agent keeps a conversation somewhere, and no reader here can read it yet
+   *  (#1822). A DIFFERENT fact from `none`, which means "this session has written nothing we can
+   *  find" — the phone falls back to the screen for both, but only one of them is worth a sentence
+   *  to a person, and only one of them is a thing to go and implement.
+   *
+   *  Never answered for a shell or a launcher cell: those have no conversation and never will, so
+   *  the screen IS their content rather than a fallback from something missing. */
+  | { status: "not-supported" };
+
+/** One page of a conversation, read backwards from `older` (#2112).
+ *
+ *  The cursor is OPAQUE to the client on purpose: it is a byte offset for the three agents that
+ *  keep a file and a `turn_index` for the one that keeps a table, and a client that knew which
+ *  would be deciding something only the host can know. It is handed back verbatim to ask for the
+ *  page before this one.
+ *
+ *  `older: null` means this page reaches the start of what can be read — either the head of the
+ *  transcript, or the point past which the host refuses to read (`status: "too-large"`).
+ *
+ *  The view is carried whole rather than flattened in beside the cursor: every non-`ok` status is
+ *  a sentence the client already knows how to show, and re-deciding them per page is how the two
+ *  ends drift. */
+export interface TranscriptPage {
+  view: TranscriptView;
+  older: string | null;
+}