fix(tui): center prose measure on shared spine

packages/merman/src/markdown.ts

@@ -1,5 +1,6 @@
 import {
   TextRenderable,
+  BoxRenderable,
   RenderableEvents,
   createMarkdownCodeBlockRenderer,
   parseColor,
@@ -33,6 +34,7 @@ interface PreparedDiagram {
   readonly source: string
   readonly text: StyledText
   readonly height: number
+  readonly width: number
 }
 
 export interface MermaidMarkdownRendererOptions {
@@ -55,16 +57,23 @@ function color(value: ColorInput | undefined): RGBA | undefined {
   return value === undefined ? undefined : parseColor(value)
 }
 
-class StaticDiagramRenderable extends TextRenderable {
+class StaticDiagramRenderable extends BoxRenderable {
   constructor(ctx: RenderContext, prepared: PreparedDiagram) {
     super(ctx, {
-      content: prepared.text,
       width: "100%",
+      alignItems: "flex-start",
+      flexShrink: 0,
+      marginTop: 1,
+    })
+    const diagram = new TextRenderable(ctx, {
+      content: prepared.text,
+      width: prepared.width,
+      maxWidth: "100%",
       height: prepared.height,
       wrapMode: "none",
       selectable: false,
-      marginTop: 1,
     })
+    this.add(diagram)
     let dragX: number | undefined
     this.onMouseDown = (event: MouseEvent) => {
       if (event.button !== 0) return
@@ -79,7 +88,7 @@ class StaticDiagramRenderable extends TextRenderable {
       if (dragX === undefined) return
       const dx = event.x - dragX
       dragX = event.x
-      if (dx) this.scrollX -= dx
+      if (dx) diagram.scrollX -= dx
     }
     this.onMouseDragEnd = (event: MouseEvent) => {
       dragX = undefined
@@ -121,6 +130,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
     case "sequence": {
@@ -144,6 +154,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
     case "state": {
@@ -168,6 +179,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
   }

packages/merman/src/test/markdown.test.ts

@@ -2,7 +2,7 @@ import { afterAll, afterEach, beforeAll, expect, test } from "bun:test"
 import { mkdir } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { CodeRenderable, MarkdownRenderable, RGBA, SyntaxStyle, TreeSitterClient } from "@opentui/core"
+import { CodeRenderable, MarkdownRenderable, RGBA, SyntaxStyle, TextRenderable, TreeSitterClient } from "@opentui/core"
 import { createTestRenderer } from "@opentui/core/testing"
 import { createMermaidMarkdownRenderer } from "../markdown.js"
 
@@ -78,6 +78,31 @@ flowchart LR
   expect(markdown.getChildren()[0]?.marginTop).toBe(1)
 })
 
+test("leaves Mermaid alignment to its containing layout", async () => {
+  const testRenderer = await createTestRenderer({ width: 80, height: 14 })
+  renderer = testRenderer.renderer
+  const markdown = new MarkdownRenderable(renderer, {
+    id: "markdown-centered-mermaid",
+    content: `\`\`\`mermaid
+flowchart LR
+  A[Start] --> B[Done]
+\`\`\``,
+    syntaxStyle,
+    treeSitterClient,
+    renderNode: createMermaidMarkdownRenderer(renderer),
+  })
+
+  renderer.root.add(markdown)
+  await renderMarkdown(markdown, testRenderer.renderOnce)
+
+  const line = testRenderer
+    .captureCharFrame()
+    .split("\n")
+    .find((value) => value.includes("Start"))
+  if (!line) throw new Error("Expected the rendered diagram")
+  expect(line.indexOf("Start")).toBeLessThan(10)
+})
+
 test("recognizes normalized Mermaid fence info strings", async () => {
   const testRenderer = await createTestRenderer({ width: 80, height: 14 })
   renderer = testRenderer.renderer
@@ -235,17 +260,19 @@ sequenceDiagram
   renderer.root.add(markdown)
   await renderMarkdown(markdown, testRenderer.renderOnce)
 
-  const diagram = markdown.getChildren()[0] as CodeRenderable
+  const wrapper = markdown.getChildren()[0]
+  if (!wrapper) throw new Error("Expected the rendered diagram wrapper")
+  const diagram = wrapper.getChildren()[0] as TextRenderable
   expect(diagram.scrollWidth).toBeGreaterThan(diagram.width)
   expect(diagram.scrollX).toBe(0)
 
-  await testRenderer.mockMouse.drag(diagram.x + 20, diagram.y + 2, diagram.x + 5, diagram.y + 2)
+  await testRenderer.mockMouse.drag(wrapper.x + 20, wrapper.y + 2, wrapper.x + 5, wrapper.y + 2)
   await testRenderer.renderOnce()
   expect(diagram.scrollX).toBeGreaterThan(0)
   expect(diagram.hasSelection()).toBe(false)
 
   diagram.scrollX = 0
-  await testRenderer.mockMouse.scroll(diagram.x + 20, diagram.y + 2, "right")
+  await testRenderer.mockMouse.scroll(wrapper.x + 20, wrapper.y + 2, "right")
   await testRenderer.renderOnce()
   expect(diagram.scrollX).toBeGreaterThan(0)
 })

packages/tui/src/component/dialog-config.tsx

@@ -60,6 +60,15 @@ export const settings: Setting[] = [
     labels: ["off", "on"],
     keywords: ["scroll bar"],
   },
+  {
+    title: "Reading width",
+    category: "Session",
+    path: ["session", "max_width"],
+    default: "auto",
+    values: ["auto", 66, 72, 80],
+    labels: ["auto", "66 columns", "72 columns", "80 columns"],
+    keywords: ["transcript", "composer", "centered", "max width", "prose"],
+  },
   {
     title: "Thinking",
     category: "Session",

packages/tui/src/config/index.tsx

@@ -125,6 +125,11 @@ export const Info = Schema.Struct({
         description: "Session sidebar visibility; 'auto' shows it when space permits",
       }),
       scrollbar: Schema.optional(Schema.Boolean).annotate({ description: "Show the session transcript scrollbar" }),
+      max_width: Schema.optional(
+        Schema.Union([Schema.Int.check(Schema.isGreaterThan(4)), Schema.Literal("auto")]),
+      ).annotate({
+        description: "Session prose and composer max width, or 'auto' to use the available width",
+      }),
       thinking: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
         description: "Show or hide model reasoning by default",
       }),

packages/tui/src/routes/session/index.tsx

@@ -68,7 +68,7 @@ import { errorMessage } from "../../util/error"
 import { useToast } from "../../ui/toast"
 import stripAnsi from "strip-ansi"
 import { usePromptRef } from "../../context/prompt"
-import { sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../ui/layout"
+import { sessionLaneLayout, sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../ui/layout"
 import { projectedPromptInput } from "../../prompt/codec"
 import { deduplicateVisibleImages } from "../../prompt/attachment"
 import { useEpilogue } from "../../context/epilogue"
@@ -108,13 +108,13 @@ import { createSingleFlight } from "../../util/single-flight"
 import type { SessionPending } from "@opencode-ai/schema/session-pending"
 import { generateThinkingSyntax } from "./thinking-syntax"
 import { createDelayedPresence } from "../../util/delayed-presence"
+import { markdownLaneMarginTop, markdownLanes } from "./markdown-lanes"
 
 addDefaultParsers(parsers.parsers)
 
 // Exclude temporary bottom space when measuring the real transcript height.
 const NAVIGATION_SLACK_ID = "session-navigation-slack"
 const BACKGROUND_TOOL_HINT_DELAY = 1_000
-
 // Tail-first transcript mounting: rows mounted with the session, then backfill cadence.
 // The tail comfortably overfills a tall viewport; backfill drains a 200-message transcript
 // in a few hundred milliseconds without a perceptible pause.
@@ -1084,55 +1084,57 @@ export function Session() {
                 {(height) => <box id={NAVIGATION_SLACK_ID} height={height()} flexShrink={0} />}
               </Show>
             </scrollbox>
-            <box flexShrink={0}>
-              <Show when={!composer.open && !disabled() && queuedPrompts().length > 0}>
-                <QueuedPromptDock prompts={queuedPrompts()} onOpen={openQueuedPrompts} />
-              </Show>
-              <PluginSlot name="session.composer.top" input={{ sessionID: route.sessionID }} mode="all" />
-              <Composer
-                sessionID={route.sessionID}
-                open={composer.open || (!!session()?.parentID && forms().length === 0)}
-                defaultTab={composer.tab ?? (session()?.parentID ? "subagents" : undefined)}
-                onClose={() => setComposer("open", false)}
-              />
-              <Switch>
-                <Match when={composer.open || (!!session()?.parentID && forms().length === 0)}>{null}</Match>
-                <Match when={promptedPermissions().length > 0}>
-                  <Show when={promptedPermissions()[0]?.id} keyed>
-                    {(_) => {
-                      const request = promptedPermissions()[0]
-                      return request ? (
-                        <PermissionPrompt request={request} directory={session()?.location.directory} />
-                      ) : null
-                    }}
-                  </Show>
-                </Match>
-                <Match when={forms().length > 0}>
-                  <Show when={forms()[0]?.id} keyed>
-                    {(_) => {
-                      const form = forms()[0]
-                      return form ? <FormPrompt form={form} /> : null
-                    }}
-                  </Show>
-                </Match>
-                <Match when={!disabled()}>
-                  <Prompt
-                    visible={true}
-                    ref={bind}
-                    disabled={false}
-                    onSubmit={() => {
-                      toBottom()
-                    }}
-                    onEmptySubmit={async () => {
-                      const next = queuedPrompts()[0]
-                      if (!next) return false
-                      return mutatePending("steer", next.id)
-                    }}
-                    sessionID={route.sessionID}
-                  />
-                </Match>
-              </Switch>
-            </box>
+            <SessionContentLane width="readable">
+              <box flexShrink={0}>
+                <Show when={!composer.open && !disabled() && queuedPrompts().length > 0}>
+                  <QueuedPromptDock prompts={queuedPrompts()} onOpen={openQueuedPrompts} />
+                </Show>
+                <PluginSlot name="session.composer.top" input={{ sessionID: route.sessionID }} mode="all" />
+                <Composer
+                  sessionID={route.sessionID}
+                  open={composer.open || (!!session()?.parentID && forms().length === 0)}
+                  defaultTab={composer.tab ?? (session()?.parentID ? "subagents" : undefined)}
+                  onClose={() => setComposer("open", false)}
+                />
+                <Switch>
+                  <Match when={composer.open || (!!session()?.parentID && forms().length === 0)}>{null}</Match>
+                  <Match when={promptedPermissions().length > 0}>
+                    <Show when={promptedPermissions()[0]?.id} keyed>
+                      {(_) => {
+                        const request = promptedPermissions()[0]
+                        return request ? (
+                          <PermissionPrompt request={request} directory={session()?.location.directory} />
+                        ) : null
+                      }}
+                    </Show>
+                  </Match>
+                  <Match when={forms().length > 0}>
+                    <Show when={forms()[0]?.id} keyed>
+                      {(_) => {
+                        const form = forms()[0]
+                        return form ? <FormPrompt form={form} /> : null
+                      }}
+                    </Show>
+                  </Match>
+                  <Match when={!disabled()}>
+                    <Prompt
+                      visible={true}
+                      ref={bind}
+                      disabled={false}
+                      onSubmit={() => {
+                        toBottom()
+                      }}
+                      onEmptySubmit={async () => {
+                        const next = queuedPrompts()[0]
+                        if (!next) return false
+                        return mutatePending("steer", next.id)
+                      }}
+                      sessionID={route.sessionID}
+                    />
+                  </Match>
+                </Switch>
+              </box>
+            </SessionContentLane>
           </Show>
         </box>
         <Show when={sidebarVisible()}>
@@ -1176,22 +1178,30 @@ function SessionRowView(props: SessionRowViewProps) {
           )}
         </Match>
         <Match when={props.row.type === "compaction-queued"}>
-          <CompactionQueued />
+          <SessionContentLane width="readable">
+            <CompactionQueued />
+          </SessionContentLane>
         </Match>
         <Match when={props.row.type === "part" ? props.row : undefined}>
           {(row) => <SessionPartView partRef={row().ref} message={props.message} />}
         </Match>
         <Match when={props.row.type === "group" && props.row.kind === "reasoning" ? props.row : undefined}>
-          {(row) => <SessionReasoningGroupView refs={row().refs} completed={row().completed} message={props.message} />}
+          {(row) => (
+            <SessionContentLane width="readable">
+              <SessionReasoningGroupView refs={row().refs} completed={row().completed} message={props.message} />
+            </SessionContentLane>
+          )}
         </Match>
         <Match when={props.row.type === "group" && props.row.kind === "exploration" ? props.row : undefined}>
           {(row) => (
-            <SessionGroupView
-              refs={row().refs}
-              pending={row().pending}
-              completed={row().completed}
-              message={props.message}
-            />
+            <SessionContentLane width="readable">
+              <SessionGroupView
+                refs={row().refs}
+                pending={row().pending}
+                completed={row().completed}
+                message={props.message}
+              />
+            </SessionContentLane>
           )}
         </Match>
         <Match when={props.row.type === "assistant-footer" ? props.row : undefined}>
@@ -1199,7 +1209,9 @@ function SessionRowView(props: SessionRowViewProps) {
             <Show when={props.message(row().messageID)}>
               {(message) => (
                 <Show when={message().type === "assistant"}>
-                  <AssistantFooter message={message() as SessionMessageAssistant} />
+                  <SessionContentLane width="readable">
+                    <AssistantFooter message={message() as SessionMessageAssistant} />
+                  </SessionContentLane>
                 </Show>
               )}
             </Show>
@@ -1207,7 +1219,13 @@ function SessionRowView(props: SessionRowViewProps) {
         </Match>
         <Match when={props.row.type === "turn-usage" ? props.row : undefined}>
           {(row) => (
-            <TurnTokenUsage messageIDs={row().messageIDs} previousCache={row().previousCache} message={props.message} />
+            <SessionContentLane width="technical">
+              <TurnTokenUsage
+                messageIDs={row().messageIDs}
+                previousCache={row().previousCache}
+                message={props.message}
+              />
+            </SessionContentLane>
           )}
         </Match>
       </Switch>
@@ -1215,6 +1233,42 @@ function SessionRowView(props: SessionRowViewProps) {
   )
 }
 
+function SessionContentLane(props: { children: JSX.Element; width: "readable" | "technical" }) {
+  const ctx = use()
+  const readable = () => ctx.config.session?.max_width ?? "auto"
+  const layout = createMemo(() => {
+    const width = readable()
+    return width === "auto" ? undefined : sessionLaneLayout(ctx.width, width)
+  })
+  return (
+    <Show when={layout()} fallback={props.children}>
+      {(value) => (
+        <box width="100%" paddingLeft={value().inset} flexShrink={0}>
+          <box width={value()[props.width]} flexShrink={0}>
+            {props.children}
+          </box>
+        </box>
+      )}
+    </Show>
+  )
+}
+
+function SessionBreakoutLane(props: { children: JSX.Element }) {
+  const ctx = use()
+  const readable = () => ctx.config.session?.max_width ?? "auto"
+  const inset = createMemo(() => {
+    const width = readable()
+    return width === "auto" ? undefined : sessionLaneLayout(ctx.width, width).inset
+  })
+  return (
+    <Show when={inset() !== undefined} fallback={props.children}>
+      <box width="100%" paddingLeft={inset()} flexShrink={0}>
+        {props.children}
+      </box>
+    </Show>
+  )
+}
+
 function TurnTokenUsage(props: {
   messageIDs: string[]
   previousCache?: CacheUsage
@@ -1377,20 +1431,35 @@ function SessionMessageView(props: { message: SessionMessageInfo }) {
         <UserMessage message={props.message as SessionMessageUser} />
       </Match>
       <Match when={props.message.type === "shell"}>
-        <ShellMessage message={props.message as Extract<SessionMessageInfo, { type: "shell" }>} />
+        <SessionContentLane width="technical">
+          <ShellMessage message={props.message as Extract<SessionMessageInfo, { type: "shell" }>} />
+        </SessionContentLane>
       </Match>
       <Match when={props.message.type === "agent-switched" || props.message.type === "model-switched"}>
-        <SessionSwitchMessageV2 message={props.message} />
+        <SessionContentLane width="readable">
+          <SessionSwitchMessageV2 message={props.message} />
+        </SessionContentLane>
       </Match>
       <Match
         when={props.message.type === "system" || props.message.type === "synthetic" || props.message.type === "skill"}
       >
-        <Show when={props.message.type === "skill"} fallback={<SessionNoticeMessageV2 message={props.message} />}>
-          <SessionSkillMessage message={props.message as Extract<SessionMessageInfo, { type: "skill" }>} />
+        <Show
+          when={props.message.type === "skill"}
+          fallback={
+            <SessionContentLane width="readable">
+              <SessionNoticeMessageV2 message={props.message} />
+            </SessionContentLane>
+          }
+        >
+          <SessionContentLane width="readable">
+            <SessionSkillMessage message={props.message as Extract<SessionMessageInfo, { type: "skill" }>} />
+          </SessionContentLane>
         </Show>
       </Match>
       <Match when={props.message.type === "compaction"}>
-        <CompactionMessage message={props.message as Extract<SessionMessageInfo, { type: "compaction" }>} />
+        <SessionContentLane width="readable">
+          <CompactionMessage message={props.message as Extract<SessionMessageInfo, { type: "compaction" }>} />
+        </SessionContentLane>
       </Match>
     </Switch>
   )
@@ -1411,11 +1480,13 @@ function SessionPartView(props: { partRef: PartRef; message: (messageID: string)
             <TextPart part={item() as SessionMessageAssistantText} last={false} />
           </Match>
           <Match when={item().type === "reasoning"}>
-            <ReasoningPart
-              part={item() as SessionMessageAssistantReasoning}
-              message={message() as SessionMessageAssistant}
-              last={false}
-            />
+            <SessionContentLane width="readable">
+              <ReasoningPart
+                part={item() as SessionMessageAssistantReasoning}
+                message={message() as SessionMessageAssistant}
+                last={false}
+              />
+            </SessionContentLane>
           </Match>
           <Match when={item().type === "tool"}>
             <ToolPart part={item() as SessionMessageAssistantTool} />
@@ -1938,79 +2009,56 @@ function UserMessage(props: { message: SessionMessageUser }) {
 
   return (
     <Show when={props.message.text.trim() || files().length || skills().length}>
-      <box
-        border={["left"]}
-        borderColor={delivery() ? theme.border.default : color()}
-        customBorderChars={SplitBorder.customBorderChars}
-      >
-        <SessionImages images={images()} paddingLeft={2} />
+      <SessionContentLane width="readable">
         <box
-          onMouseOver={() => {
-            setHover(true)
-          }}
-          onMouseOut={() => {
-            setHover(false)
-          }}
-          onMouseUp={() => {
-            if (renderer.getSelection()?.getSelectedText()) return
-            if (delivery() === "steer") {
+          border={["left"]}
+          borderColor={delivery() ? theme.border.default : color()}
+          customBorderChars={SplitBorder.customBorderChars}
+        >
+          <SessionImages images={images()} paddingLeft={2} />
+          <box
+            onMouseOver={() => {
+              setHover(true)
+            }}
+            onMouseOut={() => {
+              setHover(false)
+            }}
+            onMouseUp={() => {
+              if (renderer.getSelection()?.getSelectedText()) return
+              if (delivery() === "steer") {
+                dialog.replace(() => (
+                  <DialogSelect
+                    title="Pending steer"
+                    options={[
+                      { title: "Move to queue", value: "queue" as const },
+                      { title: "Delete", value: "cancel" as const },
+                    ]}
+                    onSelect={(option) => {
+                      void updatePendingSteer(option.value)
+                    }}
+                  />
+                ))
+                return
+              }
               dialog.replace(() => (
-                <DialogSelect
-                  title="Pending steer"
-                  options={[
-                    { title: "Move to queue", value: "queue" as const },
-                    { title: "Delete", value: "cancel" as const },
-                  ]}
-                  onSelect={(option) => {
-                    void updatePendingSteer(option.value)
-                  }}
+                <DialogMessage
+                  messageID={props.message.id}
+                  sessionID={ctx.sessionID}
+                  setPrompt={(value) => promptRef.current?.set(value)}
                 />
               ))
-              return
-            }
-            dialog.replace(() => (
-              <DialogMessage
-                messageID={props.message.id}
-                sessionID={ctx.sessionID}
-                setPrompt={(value) => promptRef.current?.set(value)}
-              />
-            ))
-          }}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          backgroundColor={hover() ? theme.raise(theme.background.default) : theme.background.default}
-          flexShrink={0}
-        >
-          <text fg={theme.text.default}>{props.message.text}</text>
-          <Show when={skills().length}>
-            <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
-              <For each={skills()}>
-                {(skill) => (
-                  <text fg={theme.text.default}>
-                    <span
-                      style={{
-                        bg: theme.hue.accent[mode() === "light" ? 700 : 200],
-                        fg: theme.background.default,
-                        bold: true,
-                      }}
-                    >
-                      {" skill "}
-                    </span>
-                    <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
-                      {` ${skill.name} `}
-                    </span>
-                  </text>
-                )}
-              </For>
-            </box>
-          </Show>
-          <Show when={files().length}>
-            <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
-              <For each={files()}>
-                {(file) => {
-                  const label = file.mime === "application/x-directory" ? "dir" : "file"
-                  return (
+            }}
+            paddingTop={1}
+            paddingBottom={1}
+            paddingLeft={2}
+            backgroundColor={hover() ? theme.raise(theme.background.default) : theme.background.default}
+            flexShrink={0}
+          >
+            <text fg={theme.text.default}>{props.message.text}</text>
+            <Show when={skills().length}>
+              <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
+                <For each={skills()}>
+                  {(skill) => (
                     <text fg={theme.text.default}>
                       <span
                         style={{
@@ -2019,20 +2067,45 @@ function UserMessage(props: { message: SessionMessageUser }) {
                           bold: true,
                         }}
                       >
-                        {` ${label} `}
+                        {" skill "}
                       </span>
                       <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
-                        {" "}
-                        {file.name ?? (file.source.type === "uri" ? file.source.uri : "attachment")}{" "}
+                        {` ${skill.name} `}
                       </span>
                     </text>
-                  )
-                }}
-              </For>
-            </box>
-          </Show>
+                  )}
+                </For>
+              </box>
+            </Show>
+            <Show when={files().length}>
+              <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
+                <For each={files()}>
+                  {(file) => {
+                    const label = file.mime === "application/x-directory" ? "dir" : "file"
+                    return (
+                      <text fg={theme.text.default}>
+                        <span
+                          style={{
+                            bg: theme.hue.accent[mode() === "light" ? 700 : 200],
+                            fg: theme.background.default,
+                            bold: true,
+                          }}
+                        >
+                          {` ${label} `}
+                        </span>
+                        <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
+                          {" "}
+                          {file.name ?? (file.source.type === "uri" ? file.source.uri : "attachment")}{" "}
+                        </span>
+                      </text>
+                    )
+                  }}
+                </For>
+              </box>
+            </Show>
+          </box>
         </box>
-      </box>
+      </SessionContentLane>
     </Show>
   )
 }
@@ -2215,14 +2288,16 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
   const theme = useTheme()
   const { currentSyntax: syntax } = useThemes()
   const plugins = usePlugin()
-  return (
-    <Show when={props.part.text.trim()}>
+  const constrained = () => (ctx.config.session?.max_width ?? "auto") !== "auto"
+
+  function Content(input: { content: string }) {
+    return (
       <box paddingLeft={3} flexShrink={0}>
         <markdown
           syntaxStyle={syntax()}
           streaming={true}
           internalBlockMode="top-level"
-          content={props.part.text.trim()}
+          content={input.content.trim()}
           tableOptions={{ style: "grid" }}
           conceal={ctx.markdownMode() === "rendered"}
           fg={theme.markdown.text}
@@ -2230,6 +2305,38 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
           renderNode={plugins.markdown()}
         />
       </box>
+    )
+  }
+
+  return (
+    <Show when={props.part.text.trim()}>
+      <Switch>
+        <Match when={!constrained()}>
+          <Content content={props.part.text} />
+        </Match>
+        <Match when={constrained()}>
+          <Index each={markdownLanes(props.part.text.trim())}>
+            {(segment, index) => {
+              const content = <Content content={segment().content} />
+              return (
+                <box width="100%" marginTop={markdownLaneMarginTop(index, segment().width)} flexShrink={0}>
+                  <Switch>
+                    <Match when={segment().width === "full"}>
+                      <SessionBreakoutLane>{content}</SessionBreakoutLane>
+                    </Match>
+                    <Match when={segment().width === "technical"}>
+                      <SessionContentLane width="technical">{content}</SessionContentLane>
+                    </Match>
+                    <Match when={segment().width === "readable"}>
+                      <SessionContentLane width="readable">{content}</SessionContentLane>
+                    </Match>
+                  </Switch>
+                </box>
+              )
+            }}
+          </Index>
+        </Match>
+      </Switch>
     </Show>
   )
 }
@@ -2238,6 +2345,7 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
 
 function ToolPart(props: { part: SessionMessageAssistantTool; images?: boolean }) {
   const display = createMemo(() => toolDisplay(props.part.name))
+  const width = createMemo(() => toolLane(props.part.name))
 
   const toolprops = {
     get metadata() {
@@ -2307,10 +2415,12 @@ function ToolPart(props: { part: SessionMessageAssistantTool; images?: boolean }
     </Switch>
   )
   return [
-    content,
-    <Show when={props.images !== false}>
-      <ToolImages parts={[props.part]} />
-    </Show>,
+    <SessionContentLane width={width()}>{content}</SessionContentLane>,
+    <SessionContentLane width="readable">
+      <Show when={props.images !== false}>
+        <ToolImages parts={[props.part]} />
+      </Show>
+    </SessionContentLane>,
   ]
 }
 
@@ -3144,7 +3254,7 @@ function Edit(props: ToolProps) {
     const diffView = ctx.config.diffs?.view
     if (diffView === "unified") return "unified"
     if (diffView === "split") return "split"
-    // Default to "auto" behavior
+    if ((ctx.config.session?.max_width ?? "auto") !== "auto") return "unified"
     return ctx.width > 120 ? "split" : "unified"
   })
 
@@ -3222,6 +3332,7 @@ function ApplyPatch(props: ToolProps) {
   const view = createMemo(() => {
     if (ctx.config.diffs?.view === "unified") return "unified"
     if (ctx.config.diffs?.view === "split") return "split"
+    if ((ctx.config.session?.max_width ?? "auto") !== "auto") return "unified"
     return ctx.width > 120 ? "split" : "unified"
   })
 
@@ -3407,11 +3518,17 @@ const toolDisplays = new Set([
   "skill",
 ])
 
+const technicalToolDisplays = new Set(["shell", "write", "edit", "execute", "patch", "generic"])
+
 export function toolDisplay(tool: string) {
   const normalized = canonicalToolName(tool)
   return toolDisplays.has(normalized) ? normalized : "generic"
 }
 
+export function toolLane(tool: string): "readable" | "technical" {
+  return technicalToolDisplays.has(toolDisplay(tool)) ? "technical" : "readable"
+}
+
 function recordValue(value: unknown): Record<string, unknown> | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return
   return value as Record<string, unknown>

packages/tui/src/routes/session/markdown-lanes.ts

@@ -0,0 +1,65 @@
+export type MarkdownLane = {
+  content: string
+  width: "readable" | "technical" | "full"
+}
+
+export function markdownLanes(content: string): MarkdownLane[] {
+  const result: MarkdownLane[] = []
+  let fence: { marker: "`" | "~"; length: number } | undefined
+  let table = false
+  const lines = content.match(/[^\n]*(?:\n|$)/g)?.filter(Boolean) ?? []
+
+  for (const [index, line] of lines.entries()) {
+    const opening = fence ? undefined : line.match(/^ {0,3}(`{3,}|~{3,})([^\n]*)/)
+    const marker = opening?.[1]
+    const tableOpening = !opening && !fence && isTableRow(line) && isTableDelimiter(lines[index + 1])
+    if (marker) fence = { marker: marker.startsWith("`") ? "`" : "~", length: marker.length }
+    if (tableOpening) table = true
+
+    const width = opening
+      ? opening[2]?.trim().split(/\s/, 1)[0]?.toLowerCase() === "mermaid"
+        ? "full"
+        : "technical"
+      : fence
+        ? (result.at(-1)?.width ?? "technical")
+        : table
+          ? "technical"
+          : "readable"
+    const previous = result.at(-1)
+    if (previous?.width === width) previous.content += line
+    else result.push({ content: line, width })
+
+    if (!fence) {
+      if (table && !isTableRow(lines[index + 1])) table = false
+      continue
+    }
+    const currentFence = fence
+    const trimmed = line.trim()
+    if (
+      !opening &&
+      (line.match(/^ */)?.[0].length ?? 0) <= 3 &&
+      trimmed.length >= currentFence.length &&
+      [...trimmed].every((character) => character === currentFence.marker)
+    ) {
+      fence = undefined
+    }
+  }
+
+  return result
+}
+
+function isTableRow(line: string | undefined) {
+  return Boolean(line?.trim() && line.includes("|"))
+}
+
+function isTableDelimiter(line: string | undefined) {
+  if (!line) return false
+  const value = line.trim().replace(/^\||\|$/g, "")
+  const cells = value.split("|")
+  return cells.length > 1 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()))
+}
+
+export function markdownLaneMarginTop(index: number, width: MarkdownLane["width"]) {
+  if (index === 0 || width === "full") return 0
+  return 1
+}

packages/tui/src/ui/layout.ts

@@ -1,6 +1,19 @@
 export const SESSION_SIDEBAR_WIDTH = 42
+export const SESSION_TECHNICAL_LANE_WIDTH = 88
 const SESSION_CONTENT_MIN_WIDTH = 44
 
 export function sessionTabsFitVertically(total: number) {
   return total >= SESSION_SIDEBAR_WIDTH + SESSION_CONTENT_MIN_WIDTH
 }
+
+// The shared spine centers the prose measure; the technical rail shares its
+// leading edge and extends rightward, clamped so it still fits the canvas.
+export function sessionLaneLayout(available: number, readable: number) {
+  const technical = Math.min(available, Math.max(readable, SESSION_TECHNICAL_LANE_WIDTH))
+  const centered = Math.floor((available - Math.min(readable, technical)) / 2)
+  return {
+    inset: Math.max(0, Math.min(centered, available - technical)),
+    readable: Math.min(readable, technical),
+    technical,
+  }
+}

packages/tui/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -10,6 +10,7 @@ import {
   parseQuestionAnswers,
   parseQuestions,
   toolDisplay,
+  toolLane,
 } from "../../../src/routes/session"
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined
@@ -131,6 +132,11 @@ describe("TUI inline tool wrapping", () => {
     expect(toolDisplay("apply_patch")).toBe("patch")
     expect(toolDisplay("patch")).toBe("patch")
     expect(toolDisplay("plugin_tool")).toBe("generic")
+    expect(toolLane("glob")).toBe("readable")
+    expect(toolLane("webfetch")).toBe("readable")
+    expect(toolLane("shell")).toBe("technical")
+    expect(toolLane("apply_patch")).toBe("technical")
+    expect(toolLane("plugin_tool")).toBe("technical")
   })
 
   test("replaces pending copy when a tool fails before completion", async () => {

packages/tui/test/cli/tui/markdown-lanes.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test"
+import { markdownLaneMarginTop, markdownLanes } from "../../../src/routes/session/markdown-lanes"
+
+test("keeps prose in the readable lane", () => {
+  expect(markdownLanes("Before\n\nAfter")).toEqual([{ content: "Before\n\nAfter", width: "readable" }])
+})
+
+test("moves Mermaid fences into the full lane", () => {
+  expect(
+    markdownLanes(`Before
+
+\`\`\`mermaid
+flowchart LR
+  A --> B
+\`\`\`
+
+After`),
+  ).toEqual([
+    { content: "Before\n\n", width: "readable" },
+    { content: "```mermaid\nflowchart LR\n  A --> B\n```\n", width: "full" },
+    { content: "\nAfter", width: "readable" },
+  ])
+})
+
+test("keeps an incomplete streaming Mermaid fence full width", () => {
+  expect(markdownLanes("Before\n```mermaid\nflowchart LR\n  A -->")).toEqual([
+    { content: "Before\n", width: "readable" },
+    { content: "```mermaid\nflowchart LR\n  A -->", width: "full" },
+  ])
+})
+
+test("supports tilde fences and longer closing fences", () => {
+  expect(markdownLanes("~~~ts\nconst value = 1\n~~~~\nAfter")).toEqual([
+    { content: "~~~ts\nconst value = 1\n~~~~\n", width: "technical" },
+    { content: "After", width: "readable" },
+  ])
+})
+
+test("does not close a fence indented as code", () => {
+  expect(markdownLanes("```ts\n    ```\nstill code")).toEqual([
+    { content: "```ts\n    ```\nstill code", width: "technical" },
+  ])
+})
+
+test("gives ordinary fenced code an intermediate lane", () => {
+  expect(markdownLanes("```ts\nexport const value = true\n```")).toEqual([
+    { content: "```ts\nexport const value = true\n```", width: "technical" },
+  ])
+})
+
+test("gives Markdown tables the technical lane", () => {
+  expect(markdownLanes("Before\n\n| Name | Value |\n| --- | ---: |\n| Width | 88 |\n\nAfter")).toEqual([
+    { content: "Before\n\n", width: "readable" },
+    { content: "| Name | Value |\n| --- | ---: |\n| Width | 88 |\n", width: "technical" },
+    { content: "\nAfter", width: "readable" },
+  ])
+})
+
+test("does not treat ordinary pipe characters as a table", () => {
+  expect(markdownLanes("Use foo | bar in prose.")).toEqual([{ content: "Use foo | bar in prose.", width: "readable" }])
+})
+
+test("restores spacing between separately rendered blocks", () => {
+  expect(markdownLaneMarginTop(0, "readable")).toBe(0)
+  expect(markdownLaneMarginTop(1, "technical")).toBe(1)
+  expect(markdownLaneMarginTop(2, "readable")).toBe(1)
+  expect(markdownLaneMarginTop(1, "full")).toBe(0)
+})

packages/tui/test/config-v2.test.tsx

@@ -27,6 +27,15 @@ test("validates the session tabs setting", () => {
   expect(decode({ session: { image_preview: true } })).toEqual({ session: { image_preview: true } })
 })
 
+test("validates the session max width setting", () => {
+  const decode = Schema.decodeUnknownSync(Info)
+
+  expect(decode({ session: { max_width: "auto" } })).toEqual({ session: { max_width: "auto" } })
+  expect(decode({ session: { max_width: 100 } })).toEqual({ session: { max_width: 100 } })
+  expect(() => decode({ session: { max_width: 4 } })).toThrow()
+  expect(() => decode({ session: { max_width: 100.5 } })).toThrow()
+})
+
 test("resolves nested config and keybind defaults", () => {
   const config = resolve(
     {
@@ -53,6 +62,13 @@ test("shows resolved tab defaults in settings", () => {
   expect(settings.find((setting) => setting.path.join(".") === "tabs.layout")?.default).toBe("horizontal")
 })
 
+test("shows session reading width presets in settings", () => {
+  const setting = settings.find((setting) => setting.path.join(".") === "session.max_width")
+
+  expect(setting?.default).toBe("auto")
+  expect(setting?.values).toEqual(["auto", 66, 72, 80])
+})
+
 test("provides config and its host interface", async () => {
   const config = resolve({}, { terminalSuspend: true })
   let current = {}

packages/tui/test/ui/layout.test.ts

@@ -1,8 +1,23 @@
 import { expect, test } from "bun:test"
-import { sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../src/ui/layout"
+import {
+  sessionLaneLayout,
+  sessionTabsFitVertically,
+  SESSION_SIDEBAR_WIDTH,
+  SESSION_TECHNICAL_LANE_WIDTH,
+} from "../../src/ui/layout"
 
 test("vertical tabs match the session sidebar and preserve compact content width", () => {
   expect(SESSION_SIDEBAR_WIDTH).toBe(42)
   expect(sessionTabsFitVertically(86)).toBe(true)
   expect(sessionTabsFitVertically(85)).toBe(false)
 })
+
+test("session lanes center the prose measure on one leading edge", () => {
+  expect(SESSION_TECHNICAL_LANE_WIDTH).toBe(88)
+  // Wide canvas: prose is truly centered, technical extends rightward.
+  expect(sessionLaneLayout(156, 66)).toEqual({ inset: 45, readable: 66, technical: 88 })
+  // Centering the prose would push the technical rail past the canvas; clamp.
+  expect(sessionLaneLayout(100, 66)).toEqual({ inset: 12, readable: 66, technical: 88 })
+  expect(sessionLaneLayout(80, 66)).toEqual({ inset: 0, readable: 66, technical: 80 })
+  expect(sessionLaneLayout(60, 66)).toEqual({ inset: 0, readable: 60, technical: 60 })
+})