@cueloop/client 0.1.0-alpha.65 → 0.1.0-alpha.67

package/src/intent-dispatch.ts

@@ -14,15 +14,11 @@ import type { DiffRow } from "./view-diff";
 import type { ReviewController } from "./session-controller";
 import type { Intent } from "./keymap";
 import type { TreeRow } from "./tree-view";
-import type { RailTab } from "./components/ReviewRail";
 import { quickActionBody, type QuickAction } from "./config";
 import { VERDICTS } from "./components/ConfirmCard";
-import {
-  REVIEW_RESIZE_STEP,
-  cycleReviewPanelMode,
-  resolveReviewWidth,
-  type ReviewPanelMode,
-} from "./review-panel";
+
+/** Which pane of the session tree / review the keyboard grammar is aimed at. */
+export type RailTab = "review" | "agent" | "tree";
 
 /** The one overlay/mode the TUI is in; every compose/submit/edit flow is a variant. */
 export type Mode =
@@ -41,6 +37,7 @@ export type Mode =
   | { type: "submit"; verdict: VerdictKind; summary: string }
   | { type: "confirmDelete"; sessionId: string; title: string }
   | { type: "rename"; authorId: string; text: string }
+  | { type: "renameThread"; sessionId: string; text: string }
   | { type: "nameSelf"; text: string }
   | { type: "treePrompt"; ask: TreeAsk; entryId?: string; text: string };
 
@@ -87,14 +84,11 @@ export interface IntentDispatchDeps {
   inboxCursor: number;
   mode: Mode;
   session: ReviewSession | null;
-  reviewMode: ReviewPanelMode;
-  reviewWidth: number;
-  terminalWidth: number;
   focusedAnnotationId: string | undefined;
-  /** The curation item selected in the rail, if any; the undo target when set. */
+  /** The curation item selected for undo, if any. */
   selectedCurationId: string | undefined;
   railTab: RailTab;
-  /** The tree row selected in the rail's Tree tab; the target of go. */
+  /** The tree row selected in the session tree; the target of go. */
   selectedEntryId: string | undefined;
   /** Planner-local author renames, for seeding the rename prompt. */
   authorNames: Record<string, string>;
@@ -102,15 +96,14 @@ export interface IntentDispatchDeps {
   quickActions: QuickAction[];
   /** Persist an author rename and update the live overrides (App-owned). */
   renameAuthor: (id: string, name: string) => void;
+  /** Rename a thread's title through the daemon. */
+  renameThread: (id: string, title: string) => void;
 
   liveInput: MutableRefObject<string>;
-  reviewWidthRef: MutableRefObject<number>;
 
   setCursor: Dispatch<SetStateAction<number>>;
   setInboxCursor: Dispatch<SetStateAction<number>>;
   setMode: Dispatch<SetStateAction<Mode>>;
-  setReviewMode: Dispatch<SetStateAction<ReviewPanelMode>>;
-  setReviewWidth: Dispatch<SetStateAction<number>>;
   setRailTab: Dispatch<SetStateAction<RailTab>>;
   setSelectedEntryId: Dispatch<SetStateAction<string | undefined>>;
   setFocusedAnnotationId: Dispatch<SetStateAction<string | undefined>>;
@@ -120,6 +113,8 @@ export interface IntentDispatchDeps {
   selectCardFromDocument: (annotationId: string) => void;
   runEditorHandOff: () => void;
   openCardEdit: (annotationId: string) => void;
+  /** Flip unified/split diff and persist it (App-owned); split lays out only when zoomed. */
+  toggleDiffView: () => void;
 }
 
 type IntentOfType<Kind extends Intent["type"]> = Extract<Intent, { type: Kind }>;
@@ -132,8 +127,55 @@ function handleStatus(intent: IntentOfType<"status">, deps: IntentDispatchDeps):
   deps.controller.setStatus(intent.message);
 }
 
+/** A diff cursor rests on code lines only; file and hunk headers are structural dividers. */
+function isCodeRow(row: DiffRow | undefined): boolean {
+  return row?.kind === "ctx" || row?.kind === "add" || row?.kind === "del";
+}
+
+/**
+ * A landable diff row: any code line, plus a collapsed file's band (a file row with
+ * no body before the next file or the end) so the cursor can reach it to expand it.
+ */
+function isLandableRow(rows: DiffRow[], index: number): boolean {
+  const row = rows[index];
+
+  if (isCodeRow(row)) return true;
+  if (row?.kind !== "file") return false;
+  const next = rows[index + 1];
+
+  return next === undefined || next.kind === "file";
+}
+
+/** The next landable index in the move direction, skipping expanded headers; stays put at an edge. */
+function nextCodeRowIndex(rows: DiffRow[], from: number, to: IntentOfType<"move">["to"]): number {
+  if (to === "top") {
+    for (let index = 0; index < rows.length; index++) if (isLandableRow(rows, index)) return index;
+
+    return from;
+  }
+  if (to === "bottom") {
+    for (let index = rows.length - 1; index >= 0; index--) {
+      if (isLandableRow(rows, index)) return index;
+    }
+
+    return from;
+  }
+  const step = to === "down" ? 1 : -1;
+
+  for (let index = from + step; index >= 0 && index < rows.length; index += step) {
+    if (isLandableRow(rows, index)) return index;
+  }
+
+  return from;
+}
+
 function handleMove(intent: IntentOfType<"move">, deps: IntentDispatchDeps): void {
-  const navigableCount = deps.isDiff ? deps.rows.length : deps.display.length;
+  if (deps.isDiff) {
+    deps.setCursor((current) => nextCodeRowIndex(deps.rows, current, intent.to));
+
+    return;
+  }
+  const navigableCount = deps.display.length;
 
   if (intent.to === "down") deps.setCursor((current) => Math.min(navigableCount - 1, current + 1));
   else if (intent.to === "up") deps.setCursor((current) => Math.max(0, current - 1));
@@ -194,6 +236,7 @@ function handleConfirmDialog(
 
   if (mode.type === "confirmDelete") controller.deleteSession(mode.sessionId);
   else if (mode.type === "rename") deps.renameAuthor(mode.authorId, mode.text.trim());
+  else if (mode.type === "renameThread") deps.renameThread(mode.sessionId, mode.text.trim());
   else if (mode.type === "nameSelf") controller.setSelfName(mode.text.trim());
   else if (mode.type === "treePrompt") confirmTreePrompt(mode, deps);
   deps.setMode({ type: "normal" });
@@ -335,11 +378,6 @@ function handleOpenSubmit(_intent: IntentOfType<"openSubmit">, deps: IntentDispa
 
   if (!session) return;
   deps.liveInput.current = "";
-  // the confirm card lives in the expanded review rail; a compact or hidden
-  // panel would swallow the whole submit flow, so force the rail open (live
-  // only - the saved panel preference is left untouched)
-  deps.setReviewMode("expanded");
-  deps.setRailTab("review");
   deps.setMode({ type: "submit", verdict: defaultVerdict(session), summary: "" });
 }
 
@@ -359,6 +397,37 @@ function handleRejectChange(_intent: IntentOfType<"rejectChange">, deps: IntentD
   deps.controller.toggleRejectChange(deps.cursor);
 }
 
+function handleFoldFile(_intent: IntentOfType<"foldFile">, deps: IntentDispatchDeps): void {
+  const file = deps.rows[deps.cursor]?.file;
+
+  if (!file || deps.controller.isFileCollapsed(file)) return;
+  deps.controller.setFileCollapsed(file, true);
+  // the file band is unchanged in index by its own collapse, so land the cursor on it
+  const headerIndex = deps.controller
+    .rows()
+    .findIndex((row) => row.kind === "file" && row.file === file);
+
+  if (headerIndex >= 0) deps.setCursor(headerIndex);
+}
+
+function handleUnfoldFile(_intent: IntentOfType<"unfoldFile">, deps: IntentDispatchDeps): void {
+  const file = deps.rows[deps.cursor]?.file;
+
+  if (!file || !deps.controller.isFileCollapsed(file)) return;
+  deps.controller.setFileCollapsed(file, false);
+  // drop the cursor onto the file's first code line now that its body is back
+  const firstCode = deps.controller.rows().findIndex((row) => row.file === file && isCodeRow(row));
+
+  if (firstCode >= 0) deps.setCursor(firstCode);
+}
+
+function handleToggleDiffView(
+  _intent: IntentOfType<"toggleDiffView">,
+  deps: IntentDispatchDeps,
+): void {
+  deps.toggleDiffView();
+}
+
 function handleRestoreCuration(
   _intent: IntentOfType<"restoreCuration">,
   deps: IntentDispatchDeps,
@@ -502,31 +571,6 @@ function handleDismissCompletion(
   deps.controller.dismissCompletion();
 }
 
-function handleCycleReviewPanel(
-  _intent: IntentOfType<"cycleReviewPanel">,
-  deps: IntentDispatchDeps,
-): void {
-  const next = cycleReviewPanelMode(deps.reviewMode);
-
-  deps.setReviewMode(next);
-  deps.controller.saveReviewPanel({ mode: next });
-}
-
-function handleResizeReviewPanel(
-  intent: IntentOfType<"resizeReviewPanel">,
-  deps: IntentDispatchDeps,
-): void {
-  if (deps.reviewMode !== "expanded") return;
-  const next = resolveReviewWidth(
-    deps.reviewWidth + intent.direction * REVIEW_RESIZE_STEP,
-    deps.terminalWidth,
-  );
-
-  deps.reviewWidthRef.current = next;
-  deps.setReviewWidth(next);
-  deps.controller.saveReviewPanel({ width: next });
-}
-
 function confirmTreePrompt(
   mode: Extract<Mode, { type: "treePrompt" }>,
   deps: IntentDispatchDeps,
@@ -613,6 +657,9 @@ const intentHandlers: IntentHandlers = {
   cut: handleCut,
   rejectHunk: handleRejectHunk,
   rejectChange: handleRejectChange,
+  foldFile: handleFoldFile,
+  unfoldFile: handleUnfoldFile,
+  toggleDiffView: handleToggleDiffView,
   restoreCuration: handleRestoreCuration,
   edit: handleEdit,
   editCard: handleEditCard,
@@ -631,8 +678,6 @@ const intentHandlers: IntentHandlers = {
   finishReview: handleFinishReview,
   optInAutoClose: handleOptInAutoClose,
   dismissCompletion: handleDismissCompletion,
-  cycleReviewPanel: handleCycleReviewPanel,
-  resizeReviewPanel: handleResizeReviewPanel,
   toggleTree: handleToggleTree,
   treeMove: handleTreeMove,
   treeGo: handleTreeGo,

package/src/key-bindings.test.ts

@@ -23,7 +23,7 @@ describe("grammar-layer resolution", () => {
     ["g", true, "bottom"],
     ["v", false, "span"],
     ["c", false, "comment"],
-    ["s", false, undefined],
+    ["s", false, "split_diff"],
     ["x", false, "cut"],
     ["e", false, "edit"],
     ["n", false, "next_annotation"],

package/src/keymap.test.ts

@@ -389,6 +389,7 @@ describe("diff mode", () => {
     ["v", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["x", [{ type: "rejectChange" }]],
     ["e", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
+    ["s", [{ type: "toggleDiffView" }]],
     ["q", [{ type: "exit" }]],
   ];
 
@@ -490,31 +491,8 @@ describe("guided walk", () => {
   });
 });
 
-describe("review panel controls", () => {
-  const table: [string, Intent[]][] = [
-    ["b", [{ type: "cycleReviewPanel" }]],
-    ["]", [{ type: "resizeReviewPanel", direction: 1 }]],
-    ["[", [{ type: "resizeReviewPanel", direction: -1 }]],
-  ];
-
-  for (const view of ["plan", "diff"] as const) {
-    for (const [name, expected] of table) {
-      test(`${view} ${name} -> ${JSON.stringify(expected)}`, () => {
-        expect(reduceKey(state({ view }), key(name))).toEqual(expected);
-      });
-    }
-  }
-
-  test("observers may still collapse and resize the panel (it is view state, not a mutation)", () => {
-    // Arrange
-    const observer = state({ readOnly: true });
-
-    // Assert
-    expect(reduceKey(observer, key("b"))).toEqual([{ type: "cycleReviewPanel" }]);
-    expect(reduceKey(observer, key("]"))).toEqual([{ type: "resizeReviewPanel", direction: 1 }]);
-  });
-
-  test("span mode still owns b as a span primitive, not a panel cycle", () => {
+describe("span and walk own their keys", () => {
+  test("span mode owns b as a span primitive", () => {
     // Assert
     expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([
       { type: "spanKey", name: "b" },

package/src/keymap.ts

@@ -33,6 +33,9 @@ export type Intent =
   | { type: "rejectHunk" }
   | { type: "rejectChange" }
   | { type: "restoreCuration" }
+  | { type: "foldFile" }
+  | { type: "unfoldFile" }
+  | { type: "toggleDiffView" }
   | { type: "nextAnnotation" }
   | { type: "prevAnnotation" }
   | { type: "walkStart" }
@@ -48,8 +51,6 @@ export type Intent =
   | { type: "finishReview" }
   | { type: "optInAutoClose" }
   | { type: "dismissCompletion" }
-  | { type: "cycleReviewPanel" }
-  | { type: "resizeReviewPanel"; direction: -1 | 1 }
   | { type: "toggleTree" }
   | { type: "treeMove"; direction: -1 | 1 }
   | { type: "treeGo" }
@@ -151,14 +152,8 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   }
 
   if (state.view === "inbox") return inboxGrammar(state, name);
-  // span mode owns its single-letter keys (b slides the span back) before the
-  // review-panel controls claim them
+  // span mode owns its single-letter keys (b slides the span back)
   if (state.spanMode) return spanGrammar(state, name);
-  // the review panel rides both plan and diff reviews; collapsing and resizing
-  // are view state, so the read-only gate above lets them through
-  const reviewPanel = reviewPanelGrammar(action);
-
-  if (reviewPanel) return reviewPanel;
   if (state.view === "diff") return diffGrammar(state, action);
 
   return planGrammar(state, action, name);
@@ -258,15 +253,6 @@ function walkOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   return [];
 }
 
-/** The review-panel controls: cycle the mode, widen and narrow the rail. */
-function reviewPanelGrammar(action: string | undefined): Intent[] | null {
-  if (action === "review_cycle") return [{ type: "cycleReviewPanel" }];
-  if (action === "review_wider") return [{ type: "resizeReviewPanel", direction: 1 }];
-  if (action === "review_narrower") return [{ type: "resizeReviewPanel", direction: -1 }];
-
-  return null;
-}
-
 function inboxGrammar(state: KeyState, name: string): Intent[] {
   if (!state.hasInboxItems) return [];
   if (name === "j" || name === "down") return [{ type: "inboxMove", to: "down" }];
@@ -301,6 +287,9 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
 
     return [{ type: action === "reject_hunk" ? "rejectHunk" : "rejectChange" }];
   }
+  const viewToggle = viewToggleIntent(action);
+
+  if (viewToggle) return viewToggle;
   // restore un-does a curated-out rejection from the rail; same owner gate as reject
   if (action === "restore_curation") {
     if (state.resolved) return status("review submitted - read-only");
@@ -382,6 +371,16 @@ function navigationIntent(action: string | undefined): Intent[] | null {
   return null;
 }
 
+/** Ungated view toggles in the diff: right folds a file to its band, left unfolds it, s flips
+ *  unified/split (split lays out only when the Changes pane is zoomed). */
+function viewToggleIntent(action: string | undefined): Intent[] | null {
+  if (action === "collapse_file") return [{ type: "foldFile" }];
+  if (action === "expand_file") return [{ type: "unfoldFile" }];
+  if (action === "split_diff") return [{ type: "toggleDiffView" }];
+
+  return null;
+}
+
 /** Annotation navigation, deletion, and submit: one path for plan and diff. */
 function annotationCluster(state: KeyState, action: string | undefined): Intent[] | null {
   if (action === "next_annotation" || action === "prev_annotation") {

package/src/mark-runs.ts

@@ -0,0 +1,120 @@
+/**
+ * Mark geometry for an annotated line of text: which stretches are marked
+ * (a discussion span, a held selection) or carry the caret cell, the greedy
+ * word wrap into visual lines, and the printable-key test that starts a
+ * comment. Renderer-free, shared by the plan thread view and the diff sheet.
+ */
+
+import type { KeyEvent } from "@opentui/core";
+import { wordRanges } from "./thread-selection";
+
+export interface MarkRange {
+  start: number;
+  end: number;
+  /** The bare caret's single cell - a cursor, not yet a mark. */
+  caretOnly?: boolean;
+}
+
+export interface Run {
+  text: string;
+  marked: boolean;
+  caretOnly: boolean;
+}
+
+/** Split a block's text into plain/marked runs from the union of ranges. */
+export function runsFor(text: string, ranges: MarkRange[]): Run[] {
+  const cuts = new Set<number>([0, text.length]);
+
+  for (const range of ranges) {
+    cuts.add(Math.max(0, range.start));
+    cuts.add(Math.min(text.length, range.end));
+  }
+  const edges = [...cuts].toSorted((left, right) => left - right);
+  const runs: Run[] = [];
+
+  for (let index = 0; index < edges.length - 1; index++) {
+    const start = edges[index]!;
+    const end = edges[index + 1]!;
+
+    if (end <= start) continue;
+    const covering = ranges.filter((range) => range.start <= start && end <= range.end);
+    // the caret cell shows through a mark, so the head of a selection is visible
+    runs.push({
+      text: text.slice(start, end),
+      marked: covering.some((range) => range.caretOnly !== true),
+      caretOnly: covering.some((range) => range.caretOnly === true),
+    });
+  }
+
+  return runs.length > 0 ? runs : [{ text, marked: false, caretOnly: false }];
+}
+
+/** A visual line of a block: the char range of the block's text it shows. */
+export interface VisualLine {
+  start: number;
+  end: number;
+}
+
+/**
+ * Greedy word wrap into visual-line char ranges, so a comment card can slot
+ * in directly below the line its mark ends on (mid-paragraph when needed).
+ */
+export function wrapLines(text: string, width: number): VisualLine[] {
+  const lines: VisualLine[] = [];
+  let segmentStart = 0;
+
+  // hard breaks first: every visual line must be exactly one terminal row,
+  // or hit-testing and the mark geometry drift from what is painted
+  for (const segment of text.split("\n")) {
+    const segmentEnd = segmentStart + segment.length;
+
+    if (width <= 0 || segment.length <= width) {
+      lines.push({ start: segmentStart, end: segmentEnd });
+    } else {
+      // greedy word wrap inside the segment; the first line keeps its
+      // leading indentation, continuation lines start at a word
+      let lineStart = segmentStart;
+      let lineEnd = segmentStart;
+
+      for (const word of wordRanges(segment)) {
+        const wordStart = segmentStart + word.start;
+        const wordEnd = segmentStart + word.end;
+
+        if (wordEnd - lineStart > width && lineEnd > lineStart) {
+          lines.push({ start: lineStart, end: lineEnd });
+          lineStart = wordStart;
+        }
+        // a token wider than the line (a long identifier, a URL) breaks at the cell edge, so
+        // every visual line stays one terminal row and nothing is clipped away
+        while (wordEnd - lineStart > width) {
+          lines.push({ start: lineStart, end: lineStart + width });
+          lineStart += width;
+        }
+        lineEnd = wordEnd;
+      }
+      lines.push({ start: lineStart, end: Math.max(lineEnd, lineStart) });
+    }
+    segmentStart = segmentEnd + 1;
+  }
+
+  return lines;
+}
+
+/** The block's mark ranges clipped to one visual line, in that line's coordinates. */
+export function lineMarkRanges(ranges: MarkRange[], line: VisualLine): MarkRange[] {
+  return ranges
+    .map((range) => ({
+      start: Math.max(range.start, line.start) - line.start,
+      end: Math.min(range.end, line.end) - line.start,
+      caretOnly: range.caretOnly,
+    }))
+    .filter((range) => range.end > range.start);
+}
+
+/** A printable character: single-width input that should reach a composer. */
+export function printableSequence(key: KeyEvent): string | null {
+  const printable =
+    key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta && key.sequence >= " ";
+
+  return printable ? key.sequence : null;
+}

package/src/pty.ts

@@ -13,8 +13,10 @@ import { join } from "node:path";
 
 const DEFAULT_COLS = 80;
 const DEFAULT_ROWS = 24;
-/** How long the read loop sleeps when the child produced no output this tick. */
+/** Shortest read-loop sleep, used while the child is actively streaming - keeps output snappy. */
 const READ_IDLE_MS = 8;
+/** Longest read-loop sleep, reached after the child sits quiet - stops the loop burning a core at idle. */
+const READ_IDLE_MAX_MS = 100;
 const READ_BUFFER_BYTES = 4096;
 /** cueloop_pty_read's sentinel: the child has exited and its output is drained. */
 const CHILD_EXITED = -2;
@@ -200,11 +202,15 @@ class Pty implements IPty {
     if (this.reading) return;
     this.reading = true;
     const buffer = Buffer.allocUnsafe(READ_BUFFER_BYTES);
+    // consecutive empty reads; the idle sleep backs off exponentially so a quiet agent prompt
+    // ramps from an 8ms hot poll up to a 100ms idle poll instead of spinning a core forever
+    let idlePolls = 0;
 
     while (!this.closing) {
       const count = this.lib.cueloop_pty_read(this.handle, ptr(buffer), buffer.length);
 
       if (count > 0) {
+        idlePolls = 0;
         // Stream mode buffers a multibyte char split across reads (box-drawing etc.).
         const text = this.decoder.decode(buffer.subarray(0, count), { stream: true });
 
@@ -221,7 +227,9 @@ class Pty implements IPty {
         this.closing = true;
         this.exitEvent.fire({ exitCode });
       } else {
-        await new Promise((resolve) => setTimeout(resolve, READ_IDLE_MS));
+        const delay = Math.min(READ_IDLE_MAX_MS, READ_IDLE_MS * 2 ** Math.min(idlePolls, 5));
+        idlePolls += 1;
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
   }

package/src/run.ts

@@ -21,18 +21,28 @@ export async function runClient(options: RunClientOptions): Promise<number> {
     (await renderer.waitForThemeMode(THEME_QUERY_TIMEOUT_MS).catch(() => null)) ?? "dark";
 
   return new Promise<number>((resolve) => {
+    let exited = false;
+    const shutdown = (code: number): void => {
+      if (exited) return;
+      exited = true;
+      renderer.destroy();
+      resolve(code);
+      // one microtask between destroy and exit lets the renderer flush
+      // its terminal-restore sequences before the process dies
+      queueMicrotask(() => process.exit(code));
+    };
+
+    // a closed pane/terminal hangs up (or the parent kills us); exit instead of
+    // lingering as an orphan whose pty read loop keeps burning CPU
+    process.once("SIGHUP", () => shutdown(0));
+    process.once("SIGTERM", () => shutdown(0));
+
     createRoot(renderer).render(
       React.createElement(App, {
         home: options.home,
         sessionId: options.sessionId,
         appearance,
-        onExit: (code: number) => {
-          renderer.destroy();
-          resolve(code);
-          // one microtask between destroy and exit lets the renderer flush
-          // its terminal-restore sequences before the process dies
-          queueMicrotask(() => process.exit(code));
-        },
+        onExit: shutdown,
       }),
     );
   });

package/src/serve.test.ts

@@ -84,18 +84,14 @@ describe("cueloop serve", () => {
     expect(existsSync(join(home, "ssh", "host_key"))).toBe(true);
   });
 
-  test("an anonymous ssh client gets the observer TUI for the session", async () => {
+  test("an anonymous ssh client gets the read-only TUI for the session", async () => {
     // Act
-    const bytes = await sshCapture(
-      handle.port,
-      (frame) => frame.includes("Rollout Plan") && frame.includes("observer"),
-    );
+    const bytes = await sshCapture(handle.port, (frame) => frame.includes("Rollout Plan"));
 
-    // Assert
+    // Assert - the viewer sees the session; read-only is enforced behaviorally
+    // (covered by the observer-primitives tests), not by a header badge
     expect(bytes).toContain("cueloop");
     expect(bytes).toContain("Rollout Plan");
-    // observer chrome: the header badge marks the read-only session
-    expect(bytes).toContain("observer");
   });
 
   test("two observers can watch at once", async () => {

package/src/session-controller.curate.test.ts

@@ -114,6 +114,7 @@ function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClien
     sessionLabel: unimplemented("sessionLabel"),
     sessionFork: unimplemented("sessionFork"),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
@@ -360,3 +361,77 @@ describe("plan cut removals", () => {
     expect(sink.workingCopy).toBe("# Title\n");
   });
 });
+
+// a file whose hunk touches line 2 only, so lines 1/3/4 are unchanged tail/context
+const TAIL_PATCH = `diff --git a/src/store.ts b/src/store.ts
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -2,1 +2,1 @@
+-  private items = [];
++  private items = new Map();
+`;
+
+function tailSession(): ReviewSession {
+  return {
+    ...diffSession(),
+    artifact: {
+      type: "diff",
+      content: TAIL_PATCH,
+      meta: {},
+      files: [
+        {
+          path: "src/store.ts",
+          oldContents: "export class Store {\n  private items = [];\n}\nexport const x = 1;\n",
+          newContents:
+            "export class Store {\n  private items = new Map();\n}\nexport const x = 1;\n",
+          status: "modified",
+        },
+      ],
+    },
+  };
+}
+
+describe("diff file fold", () => {
+  test("collapse leaves only the file band; expand restores the body", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const bodyRows = () =>
+      controller.rows().filter((row) => row.file === "src/store.ts" && row.kind !== "file").length;
+
+    // Assert - starts unfolded with a body
+    expect(bodyRows()).toBeGreaterThan(0);
+
+    // Act / Assert - collapse hides the body
+    controller.setFileCollapsed("src/store.ts", true);
+    expect(bodyRows()).toBe(0);
+    expect(controller.isFileCollapsed("src/store.ts")).toBe(true);
+
+    // Act / Assert - unfold brings it back
+    controller.setFileCollapsed("src/store.ts", false);
+    expect(bodyRows()).toBeGreaterThan(0);
+  });
+
+  test("expand weaves the file's unchanged tail line the hunk never showed", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const hasTail = () => controller.rows().some((row) => row.text.includes("export const x = 1"));
+
+    // Assert - the hunk view does not show the tail line
+    expect(controller.canExpandFile("src/store.ts")).toBe(true);
+    expect(hasTail()).toBe(false);
+
+    // Act - weave the full file
+    controller.setFileExpanded("src/store.ts", true);
+
+    // Assert
+    expect(hasTail()).toBe(true);
+  });
+
+  test("a diff without full contents cannot be expanded", async () => {
+    // Arrange - no artifact.files
+    const { controller } = await connected(diffSession(undefined));
+
+    // Assert
+    expect(controller.canExpandFile("src/store.ts")).toBe(false);
+  });
+});

package/src/session-controller.share.test.ts

@@ -78,6 +78,7 @@ function fakeClient(session: ReviewSession): FakeSessionClient {
     sessionLabel: unimplemented("sessionLabel"),
     sessionFork: unimplemented("sessionFork"),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: mock(
       async (_id: string, shareId: string) => ((session.shareId = shareId), session),
     ),