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

package/src/App.tsx

@@ -1,14 +1,3 @@
-/**
- * The cueloop TUI: state wiring, keymap dispatch, and layout composition -
- * nothing else. Rendering lives in components/, daemon IO and the mutation
- * primitives in session-controller.ts, the keyboard grammar in keymap.ts with
- * binding resolution and status hints from key-bindings.ts, and theming in
- * the ThemeProvider. Selection is the entry primitive (mouse drag or keyboard
- * span on one native renderer selection); annotation text lives in the rail
- * while the document keeps only the highlight, and one selected id drives
- * both sides.
- */
-
 import React, {
   useCallback,
   useEffect,
@@ -45,14 +34,15 @@ import type { SessionClient } from "@cueloop/daemon/client";
 import { createIntentDispatch, type Mode, type RailTab } from "./intent-dispatch";
 import { reduceKey, type KeyState } from "./keymap";
 import { KeyBindings, type CheatsheetSection } from "./key-bindings";
+import { useReadySignal } from "./ready-signal";
 import { ThemeProvider } from "./components/theme-context";
 import { Button } from "./components/primitives/Button";
 import { Toolbar } from "./components/primitives/Toolbar";
 import { groupInbox, projectName, threadTitle } from "./components/session-tree";
-import { InboxList } from "./components/InboxList";
+import { ThreadTree } from "./components/ThreadTree";
 import { ChangesFileTree } from "./components/ChangesColumn";
 import { ProjectTreeView } from "./components/ProjectTreeView";
-import { FileContentsView } from "./components/FileContentsView";
+import { AnnotatableFileView } from "./components/AnnotatableFileView";
 import { AppShell, type ProjectPanelMode } from "./components/AppShell";
 import { EditorGrid } from "./components/EditorGrid";
 import type { EditorTab } from "./components/editor-grid";
@@ -67,16 +57,22 @@ import {
   THREAD_CHORD_ENTRIES,
   TREE_CHORD_ENTRIES,
 } from "./thread-chords";
-import { DiffSheet, type DiffFoldControls, type DiffSheetProps } from "./components/DiffSheet";
-import { commentCountsByFile, marksByRows, type DiffRow } from "./view-diff";
-import type { DiffFileContents } from "@cueloop/schema";
-import { PrototypeSheet } from "./components/PrototypeSheet";
+import {
+  DiffContentView,
+  type DiffFoldControls,
+  type DiffContentViewProps,
+} from "./components/DiffContentView";
+import { commentCountsByFile, fileTargetMarks, marksByRows, type DiffRow } from "./view-diff";
+import { annotationTarget, type Anchor } from "@cueloop/schema";
+import type { DiffFileContents, ReviewSession } from "@cueloop/schema";
+import { PrototypePixels } from "./prototype-pixels";
 import type { PrototypeElement } from "./prototype-browser";
 import {
   buildRenderFlags,
   buildSubmitConfirmState,
   computeRoleCapabilities,
   deriveReviewFlags,
+  isPixelPrototypeMode,
   isCompletionOverlayPhase,
   isWalking,
   resolveOverlay,
@@ -105,6 +101,8 @@ export interface AppProps {
    */
   readOnly?: boolean;
   onExit?: (code: number) => void;
+  /** Fired once, after the first frame that paints a usable screen with its keyboard handlers live (ready-signal.ts). */
+  onReady?: () => void;
   /** Timer source for the auto-close countdown; tests inject a ManualClock. */
   clock?: Clock;
   /** Session source; the sharing gateway injects a blob-backed client. */
@@ -146,10 +144,11 @@ function canSubmitReview(isOwner: boolean, resolved: boolean, observer: boolean)
 
 /** The inline-commenting props the diff sheet shares with the thread view, wired once by the app. */
 type DiffSurfaceProps = Pick<
-  DiffSheetProps,
+  DiffContentViewProps,
   | "session"
   | "quickActions"
   | "observer"
+  | "commentsEnabled"
   | "resolved"
   | "suspended"
   | "onComposingChange"
@@ -174,10 +173,20 @@ function ChangesTabBody(props: {
   dimmed: boolean;
   theme: Theme;
 }): React.ReactNode {
+  const annotations = props.surface.session.annotations;
+  // a diff thread's Changes view is the artifact itself; any other thread's is the working-tree diff,
+  // whose notes carry a file target and resolve per file - each surface paints only its own notes
+  const forArtifact = props.surface.session.artifact.type === "diff";
   const marks = useMemo(
     () =>
-      marksByRows(props.surface.session.annotations, props.rows, props.surface.focusedAnnotationId),
-    [props.surface.session.annotations, props.rows, props.surface.focusedAnnotationId],
+      forArtifact
+        ? marksByRows(
+            annotations.filter((annotation) => annotationTarget(annotation).kind === "artifact"),
+            props.rows,
+            props.surface.focusedAnnotationId,
+          )
+        : fileTargetMarks(annotations, props.rows, props.surface.focusedAnnotationId),
+    [annotations, forArtifact, props.rows, props.surface.focusedAnnotationId],
   );
 
   if (props.rows.length === 0) {
@@ -189,7 +198,7 @@ function ChangesTabBody(props: {
   }
 
   return (
-    <DiffSheet
+    <DiffContentView
       rows={props.rows}
       marks={marks}
       {...props.surface}
@@ -213,11 +222,35 @@ function GridTabContent(props: {
   split?: boolean;
   dimmed: boolean;
   readFile: (path: string) => Promise<string | null>;
+  /** Persist a comment on a project file; the file view built the anchor against its own lines. */
+  onAddFileComment: (path: string, anchor: Anchor, body: string) => void;
   theme: Theme;
 }): React.ReactNode {
   const { tab } = props;
   if (tab.kind === "file" && tab.fileView === "contents" && tab.path !== undefined) {
-    return <FileContentsView path={tab.path} loadContents={props.readFile} theme={props.theme} />;
+    const filePath = tab.path;
+
+    return (
+      <AnnotatableFileView
+        path={filePath}
+        loadContents={props.readFile}
+        session={props.surface.session}
+        quickActions={props.surface.quickActions}
+        observer={props.surface.observer}
+        resolved={props.surface.resolved}
+        suspended={props.surface.suspended}
+        focusedAnnotationId={props.surface.focusedAnnotationId}
+        onFocusAnnotation={props.surface.onFocusAnnotation}
+        onComposingChange={props.surface.onComposingChange}
+        onCursorChange={props.surface.onCursorChange}
+        onObserverBlocked={props.surface.onObserverBlocked}
+        onAddComment={(anchor, body) => props.onAddFileComment(filePath, anchor, body)}
+        onReply={props.surface.onReply}
+        onUpdateAnnotation={props.surface.onUpdateAnnotation}
+        onExit={props.surface.onExit}
+        theme={props.theme}
+      />
+    );
   }
   if (tab.kind !== "file") {
     return (
@@ -319,6 +352,15 @@ function ProjectPanelBody(props: {
   );
 }
 
+/** The render tree has left the connecting screen: an error, a session, or the no-thread shell. */
+function usableScreenReached(
+  error: string | null,
+  session: ReviewSession | null,
+  inbox: ReviewSession[] | null,
+): boolean {
+  return Boolean(error) || session !== null || inbox !== null;
+}
+
 /** The keybinds dialog content: the thread grammar while the thread view owns the keys. */
 function cheatsheetFor(keyBindings: KeyBindings, threadViewActive: boolean): CheatsheetSection[] {
   const base = keyBindings.cheatsheet();
@@ -343,6 +385,7 @@ export function App({
   cwd,
   readOnly = false,
   onExit,
+  onReady,
   clock,
   openClient,
   shareTransport,
@@ -372,8 +415,8 @@ export function App({
 
     return () => controller.close();
   }, [controller]);
-  // stable across renders so the memoized PrototypeSheet is not re-rendered by
-  // unrelated App state (status ticks, a rail-width drag)
+  // stable across renders so the memoized PrototypeContentView is not
+  // re-rendered by unrelated App state (status ticks, a rail-width drag)
   const onCommentPrototype = useCallback(
     (element: PrototypeElement, body: string) =>
       controller.annotatePrototype(element.selector, element.quote, body),
@@ -424,7 +467,7 @@ export function App({
   const [menuDialog, setMenuDialog] = useState<"keybinds" | "settings" | null>(null);
   const [autoClose, setAutoClose] = useState<AutoClose>("off");
   // unified or side-by-side diff; split only lays out when the Changes pane is zoomed
-  const [diffView, setDiffView] = useState<DiffViewMode>("unified");
+  const [diffView, setDiffView] = useState<DiffViewMode>("split");
   const [focusedAnnotationId, setFocusedAnnotationId] = useState<string | undefined>(undefined);
   const [selectedCurationId, setSelectedCurationId] = useState<string | undefined>(undefined);
   const [railTab, setRailTab] = useState<RailTab>("review");
@@ -444,10 +487,13 @@ export function App({
   const [themeOverrides, setThemeOverrides] = useState<Partial<Theme>>({});
   const [authorNames, setAuthorNames] = useState<Record<string, string>>({});
   const [quickActions, setQuickActions] = useState<QuickAction[]>(DEFAULT_QUICK_ACTIONS);
+  // opt-in: render a prototype as a kitty pixel mockup instead of the markdown doc
+  const [prototypePixels, setPrototypePixels] = useState(false);
 
   useEffect(() => {
     const config = loadConfig({ repoRoot: session?.workspace.repoRoot });
 
+    setPrototypePixels(config.experimental.prototypePixels);
     keysRef.current = config.keys;
     keyBindings.setKeys(config.keys);
     setTheme(composeTheme(config.ui.theme, config.themeOverrides, appearance));
@@ -517,7 +563,14 @@ export function App({
   const marks = useMemo(
     () =>
       session
-        ? marksByDisplay(session.annotations, display, pulsedAnnotationId ?? undefined)
+        ? marksByDisplay(
+            // the plan thread shows only artifact notes; Changes-diff notes render on that surface
+            session.annotations.filter(
+              (annotation) => annotationTarget(annotation).kind === "artifact",
+            ),
+            display,
+            pulsedAnnotationId ?? undefined,
+          )
         : new Map<number, Mark[]>(),
     [session, display, pulsedAnnotationId],
   );
@@ -532,6 +585,13 @@ export function App({
     return ids;
   }, [marks]);
   const { isDiff, isPrototype, resolved } = deriveReviewFlags(session);
+  // a prototype is a markdown design doc by default; only the opt-in experimental
+  // pixel mode (flag on + an HTML entry) renders it as a kitty mockup instead
+  const isPixelPrototype = isPixelPrototypeMode(
+    isPrototype,
+    prototypePixels,
+    session?.artifact.meta.prototypePath,
+  );
   // comments per changed-file path, for the changed-files tree and tab badges
   const diffCommentCounts = useMemo(
     () => (session && isDiff ? commentCountsByFile(session, rows) : undefined),
@@ -539,11 +599,12 @@ export function App({
   );
   // entering a diff opens the right region in changed-files mode; a plan or reply opens it closed
   workbench.syncSession(session?.id, isDiff);
-  // plans and replies open in the thread view, diffs in the diff sheet: both drive the shared
-  // annotation surface and own the document grammar; only the prototype keeps the keymap
-  const threadViewActive = session !== null && !isPrototype;
+  // plans, replies, and the default (markdown) prototype open in the thread view, diffs in the
+  // diff sheet: both drive the shared annotation surface; only the pixel prototype keeps the keymap
+  const threadViewActive = session !== null && !isPixelPrototype;
   const [threadComposing, setThreadComposing] = useState(false);
   const [prototypeComposing, setPrototypeComposing] = useState(false);
+  const [welcomeComposing, setWelcomeComposing] = useState(false);
   // sort position per annotation so the rail interleaves annotation and removal
   // cards in one line-ordered stack: a diff row carries its blockIndex; a plan
   // annotation resolves to the display index it marked
@@ -624,12 +685,14 @@ export function App({
     runEditorHandOff,
     openCardEdit,
     toggleDiffView: () => {
-      const next: DiffViewMode = diffView === "unified" ? "split" : "unified";
+      const next: DiffViewMode = diffView === "stacked" ? "split" : "stacked";
 
       setDiffView(next);
       persistDiffView(next);
-      if (next === "split" && !workbench.zoomed)
-        controller.setStatus("split diff shows when zoomed");
+      // every toggle names the new mode; picking split on a narrow pane also says it needs the wide layout
+      if (next === "stacked") controller.setStatus("stacked diff");
+      else if (workbench.zoomed) controller.setStatus("split diff");
+      else controller.setStatus("split diff shows when zoomed");
     },
   });
 
@@ -658,9 +721,9 @@ export function App({
 
       return;
     }
-    // The prototype compose textarea owns the keyboard while open: let it receive
-    // the typed note instead of the global keymap acting on each letter.
-    if (prototypeComposing) return;
+    // A compose textarea owns the keyboard while open: let it receive the typed note instead of the
+    // global keymap acting on each letter (the prototype, and the bare-shell welcome playground).
+    if (prototypeComposing || welcomeComposing) return;
     if (menuDialog === "settings") return void handleSettingsKey(key.name);
     if (menuDialog) return void (key.name === "escape" && setMenuDialog(null));
     // the toast is non-modal: escape only dismisses it when nothing else owns
@@ -702,6 +765,9 @@ export function App({
       dispatch(intent);
   });
 
+  // after every keyboard hook above, so their subscriptions precede the signal
+  useReadySignal(usableScreenReached(error, session, inbox), onReady);
+
   // ── shared bottom chrome: the menu bar and its drop-up dialogs, one render
   // reused by the inbox and by plan/diff review so the two never drift ──
   const menuChrome = (
@@ -735,6 +801,8 @@ export function App({
         pinnedIds={pinnedIds}
         onPin={togglePin}
         onRename={(id, title) => setMode({ type: "renameThread", sessionId: id, text: title })}
+        quickActions={quickActions}
+        onWelcomeComposingChange={setWelcomeComposing}
       />
     ) : (
       <ConnectingScreen theme={theme} />
@@ -776,7 +844,7 @@ export function App({
     session: activeSession,
     isOwner,
     isDiff,
-    isPrototype,
+    isPixelPrototype,
     resolved,
     menuDialog,
     resolvedIds,
@@ -812,7 +880,7 @@ export function App({
         onOpenMenu={() => setMenuDialog("settings")}
         threadsPanel={
           <scrollbox style={{ flexGrow: 1 }} focused={false}>
-            <InboxList
+            <ThreadTree
               rows={grouped.rows}
               cursor={inboxCursor}
               activeId={activeSession.id}
@@ -843,10 +911,9 @@ export function App({
         threadPanel={
           <box style={{ flexGrow: 1, flexDirection: "column" }}>
             <box style={{ flexGrow: 1, flexDirection: "row" }}>
-              {isPrototype ? (
-                <PrototypeSheet
+              {isPixelPrototype ? (
+                <PrototypePixels
                   prototypePath={prototypePath}
-                  quickActions={quickActions}
                   canComment={prototypeCanComment}
                   onCommentElement={onCommentPrototype}
                   onComposingChange={setPrototypeComposing}
@@ -930,6 +997,7 @@ export function App({
                   session: activeSession,
                   quickActions,
                   observer,
+                  commentsEnabled: true,
                   resolved,
                   suspended: threadViewSuspended || !groupFocused,
                   onComposingChange: setThreadComposing,
@@ -942,6 +1010,8 @@ export function App({
                   onCursorChange: setCursor,
                   focusedAnnotationId,
                   onFocusAnnotation: setFocusedAnnotationId,
+                  // a diff thread's Changes view is the artifact itself; any other thread's is the
+                  // live working-tree diff, so its notes carry a file target and anchor there
                   onAnnotate: (span, body) =>
                     void controller.annotate(
                       "comment",
@@ -950,6 +1020,7 @@ export function App({
                       span.end.char,
                       body,
                       span.end.blockIndex,
+                      isDiff ? { kind: "artifact" } : { kind: "file", path: "", rev: "worktree" },
                     ),
                   onReply: (rootAnnotationId, body) =>
                     void controller.reply(rootAnnotationId, body),
@@ -962,6 +1033,9 @@ export function App({
                 split={diffView === "split" && workbench.zoomed}
                 dimmed={walking}
                 readFile={(path) => controller.repoReadFile(path)}
+                onAddFileComment={(path, anchor, body) =>
+                  void controller.addComment(anchor, { kind: "file", path, rev: "worktree" }, body)
+                }
                 theme={theme}
               />
             )}
@@ -974,8 +1048,9 @@ export function App({
             loadChanges={() => controller.repoChanges()}
             loadProjectFiles={() => controller.repoFiles()}
             reloadKey={activeSession.id}
-            // a diff review opens a changed file as its captured diff; other threads show live contents
-            onOpenChangedFile={(path) => workbench.openFile(path, isDiff ? "diff" : "contents")}
+            // the Changes navigator always opens a changed file as a diff - a diff review shows its
+            // captured snapshot, every other thread the live working-tree diff
+            onOpenChangedFile={(path) => workbench.openFile(path, "diff")}
             onOpenProjectFile={(path) => workbench.openFile(path, "contents")}
             commentCounts={diffCommentCounts}
             theme={theme}

package/src/App.walk.test.tsx

@@ -5,7 +5,6 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import React from "react";
-import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
@@ -14,6 +13,7 @@ import {
   isolateUserConfig,
   press,
   pressKey,
+  renderReadyApp,
   waitForState,
   waitForText,
   waitForTextGone,
@@ -66,7 +66,7 @@ afterEach(() => {
 });
 
 async function renderApp() {
-  const setup = await testRender(<App home={home} sessionId={session.id} />, {
+  const setup = await renderReadyApp(<App home={home} sessionId={session.id} />, {
     width: 120,
     height: 34,
   });

package/src/App.workbench.test.tsx

@@ -15,7 +15,16 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
-import { isolateUserConfig, locateText, waitForState, waitForText } from "./test-support";
+import {
+  dragText,
+  isolateUserConfig,
+  locateText,
+  pressKey,
+  typeText,
+  waitForState,
+  waitForText,
+  renderReadyApp,
+} from "./test-support";
 import { NERD } from "./components/primitives/icons";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
@@ -73,7 +82,7 @@ afterEach(() => {
 });
 
 async function renderApp() {
-  const setup = await testRender(<App home={home} sessionId={session.id} />, {
+  const setup = await renderReadyApp(<App home={home} sessionId={session.id} />, {
     width: 160,
     height: 20,
   });
@@ -183,17 +192,17 @@ describe("the four-pane workbench", () => {
     expect(diffToggleColumn(setup)).toBeGreaterThan(0);
   });
 
-  test("the right-sidebar toggle collapses the region to a rail and reopens it", async () => {
+  test("the right-sidebar toggle closes the region and its header toggle reopens it", async () => {
     const setup = await renderApp();
 
     await setup.mockMouse.click(rightToggleColumn(setup), HEADER_ROW);
     await waitForState(setup, () => !setup.captureCharFrame().includes("store.ts"));
 
-    // the right region is closed: no Changes editor, no Project tree toggles
+    // the right region is closed: no Changes editor, no Project tree toggles, no gutter
     expect(setup.captureCharFrame()).not.toContain("store.ts");
     expect(diffToggleColumn(setup)).toBe(-1);
 
-    // the collapsed rail shows the outline (off) variant; its toggle reopens the region
+    // the reopen toggle (outline/off variant) rides the thread header; clicking it reopens the region
     await setup.mockMouse.click(railToggleColumn(setup), HEADER_ROW);
     await waitForText(setup, "store.ts");
     expect(diffToggleColumn(setup)).toBeGreaterThan(0);
@@ -271,7 +280,7 @@ describe("the four-pane workbench", () => {
 /** The bare-launch (no thread) shell is the same four panes as a thread: the Thread pane waits in its
  * empty state and a disposable Welcome tab rides in the Changes editor. The right-region toggles behave
  * like the thread shell, dismissing Welcome collapses the editor without stranding an empty screen, and
- * the collapsed rail draws its divider in the header only. */
+ * a closed right region moves its reopen toggle into the header rather than leaving a gutter. */
 describe("the bare-launch welcome shell", () => {
   let welcomeHome: string;
   let welcomeRepo: string;
@@ -313,6 +322,38 @@ describe("the bare-launch welcome shell", () => {
     expect(setup.captureCharFrame()).toContain("README.md");
   });
 
+  test("the first comment in the bare shell creates and persists a per-repo workbench thread", async () => {
+    const setup = await renderWelcome();
+
+    // open a project file in the bare shell (no thread yet - nothing on disk)
+    expect(welcomeServer.core.sessionList().length).toBe(0);
+    await setup.mockMouse.click(treeToggleColumn(setup), HEADER_ROW);
+    await waitForText(setup, "README.md");
+    const readme = locateText(setup, "README.md");
+    await setup.mockMouse.click(readme.column, readme.row);
+    await waitForText(setup, "edited in the working tree");
+
+    // comment on a line - the first note find-or-creates the workbench thread
+    const line = "edited in the working tree";
+    await dragText(setup, line, line, line.length);
+    await typeText(setup, "workbench note");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // the daemon persisted one per-repo workbench thread carrying the note
+    await waitForState(setup, () =>
+      welcomeServer.core.sessionList().some((thread) => thread.artifact.meta.workbench === true),
+    );
+    const workbench = welcomeServer.core
+      .sessionList()
+      .find((thread) => thread.artifact.meta.workbench === true)!;
+    expect(workbench.workspace.rootCommit).toBeTruthy();
+    await waitForState(setup, () =>
+      welcomeServer.core
+        .sessionGet(workbench.id)
+        .annotations.some((note) => note.body.includes("workbench note")),
+    );
+  });
+
   test("the changes tree lists the launch repo's working-tree changes", async () => {
     const setup = await renderWelcome();
 
@@ -324,12 +365,42 @@ describe("the bare-launch welcome shell", () => {
   test("a bare launch rides a Welcome tab in the editor while the Thread pane waits empty", async () => {
     const setup = await renderWelcome();
 
+    // the Welcome playground measures its width before it paints, so wait for its copy
+    await waitForText(setup, "Getting started");
     const frame = setup.captureCharFrame();
     // the getting-started surface is an editor tab, not the thread pane
     expect(frame.split("\n")[HEADER_ROW]!).toContain("Welcome");
-    expect(frame).toContain("Welcome to cueloop");
+    expect(frame).toContain("Getting started");
     // the Thread pane shows its empty state until a thread is opened
-    expect(frame).toContain("Select a thread");
+    expect(frame).toContain("no threads");
+  });
+
+  test("typing in the welcome composer never reaches the inbox keys", async () => {
+    // a pending thread in the sidebar so the inbox keys (delete, open) have a target to act on
+    welcomeServer.core.sessionCreate({
+      workspace: { repoRoot: welcomeRepo, branch: "main" },
+      artifact: { type: "plan", content: "# Seeded\n", meta: { title: "Seeded Plan" } },
+    });
+    const setup = await testRender(
+      <App home={welcomeHome} sessionId={undefined} cwd={welcomeRepo} />,
+      { width: 160, height: 28 },
+    );
+    await waitForText(setup, "quick brown fox");
+
+    // open the playground composer, then type letters that are also inbox keys (j, k, d), one at a
+    // time as a person would - each keystroke settles a frame, the way real input arrives
+    await dragText(setup, "quick brown fox", "quick brown fox", "quick brown fox".length);
+    for (const character of "note: jkd") await typeText(setup, character);
+    await waitForText(setup, "note: jkd");
+
+    // the letters landed in the note, not the inbox: no delete confirmation opened
+    expect(setup.captureCharFrame()).not.toContain("This removes the plan");
+
+    // Cmd+Enter saves the note; it must not dispatch openSession and replace the playground
+    await pressKey(setup, "RETURN", { meta: true });
+    expect(setup.captureCharFrame()).toContain("Getting started");
+
+    setup.renderer.destroy();
   });
 
   test("dismissing the Welcome tab collapses the editor without stranding an empty screen", async () => {
@@ -340,13 +411,13 @@ describe("the bare-launch welcome shell", () => {
     await setup.mockMouse.click(welcome.column + 8, welcome.row);
     await waitForState(
       setup,
-      () => !setup.captureCharFrame().includes("review loop for coding agents"),
+      () => !setup.captureCharFrame().includes("comment on agent-authored work"),
     );
 
     // the Threads sidebar and the Thread empty state remain - never a blank shell
     const frame = setup.captureCharFrame();
     expect(frame).toContain("cueloop");
-    expect(frame).toContain("Select a thread");
+    expect(frame).toContain("no threads");
   });
 
   test("the changed-files and tree toggles switch navigator mode without collapsing", async () => {
@@ -364,20 +435,20 @@ describe("the bare-launch welcome shell", () => {
     await waitForState(setup, () => !setup.captureCharFrame().includes("src"));
     expect(diffToggleColumn(setup)).toBeGreaterThan(0);
 
-    // the sidebar toggle collapses the region to a rail
+    // the sidebar toggle closes the region
     await setup.mockMouse.click(rightToggleColumn(setup), HEADER_ROW);
     await waitForState(setup, () => diffToggleColumn(setup) === -1);
   });
 
-  test("the collapsed rail draws its divider in the header only, not full-height", async () => {
+  test("a closed region draws its reopen divider in the header only, not full-height", async () => {
     const setup = await renderWelcome();
 
-    // collapse the right region so only the rail remains
+    // close the right region so only the header toggle remains
     await setup.mockMouse.click(rightToggleColumn(setup), HEADER_ROW);
     await waitForState(setup, () => diffToggleColumn(setup) === -1);
 
     const lines = setup.captureCharFrame().split("\n");
-    // the rail's divider sits at the far right; find its column on the header row
+    // the reopen toggle's divider sits at the far right; find its column on the header row
     const headerDivider = lines[HEADER_ROW]!.lastIndexOf("│");
     expect(headerDivider).toBeGreaterThan(0);
     // that column stays clear below the two-row header - no full-height column rule