feat(lanes,ui): per-lane git surface — Changes panel, VS Code-style diff, branch-aware Add lane, redesigned tooltips (#34, #35)

- Changes card beside lane detail with five modes: Files tree, overview,
  Review (whole diff, per-file collapse), single file, commit history.
- LaneDiffView: unified / side-by-side with independent scroll on both axes
  and mirrored scrollLeft, expand/collapse context, intra-line emphasis.
- Staged-only commit box; git actions (fetch/pull/push/stage/unstage/
  discard/commit/switch/branch-create/branch-delete) guarded in git-ops.js.
- Server: git-diff.js + git-ops.js behind GET /api/lanes/:id/git/* and
  POST /api/lanes/:id/git/:action; gitFacts gains upstream/ahead/behind.
- Add lane: new/existing branch, current branch, worktree list, prefill
  from the git bar's "New lane here"; /api/run/cwds gains a repo kind.
- GlobalTooltip upgrades every native title into a themed anchored bubble;
  chart/info popovers use theme tokens.

client/README.md

@@ -726,6 +726,25 @@ flowchart LR
 
 Renders the hook payload for a single event inline below its row. Scalars appear as `key: value` pairs; objects and arrays render in a terminal-styled code block with a copy button.
 
+#### Tooltips (`components/Tooltip.tsx`)
+
+`GlobalTooltip` is mounted once in `App.tsx` and gives **every** control in the
+app the same designed tooltip — there is no wrapper to add at the call site.
+It listens at the document, and on hover (after a 350 ms rest) or on keyboard
+focus (immediately) it takes the element's native `title`, shows it as an
+anchored bubble with an arrow, and puts the attribute back when the bubble
+closes. Consequences worth knowing:
+
+- **Write `title="…"` exactly as before.** That is the whole API. A control
+  keeps its native tooltip, and its accessible name, when JS has not run.
+- **Opt out with `data-tip-off`** where the browser's own tooltip is wanted.
+- The bubble is built from theme tokens (`TOOLTIP_SURFACE`), so it is legible
+  in light mode; it flips above/below, clamps to the viewport, and closes on
+  scroll, resize, pointer-down or `Escape`.
+- `Tip` (`components/Tip.tsx`) stays separate and cursor-following for
+  expanding a truncated **number** inside a line of text, but draws the same
+  surface so the two read as one thing.
+
 ---
 
 ## Utilities

client/src/App.tsx

@@ -60,6 +60,7 @@ import { useCallback } from "react";
 import { Layout } from "./components/Layout";
 import { DocumentTitle } from "./components/DocumentTitle";
 import { SplashScreen } from "./components/SplashScreen";
+import { GlobalTooltip } from "./components/Tooltip";
 import { Dashboard } from "./pages/Dashboard";
 import { History } from "./pages/History";
 import { SessionDetail } from "./pages/SessionDetail";
@@ -87,6 +88,9 @@ export default function App() {
   return (
     <>
       <SplashScreen />
+      {/* One renderer gives every `title` in the app the designed bubble —
+          see components/Tooltip.tsx for why it is not a wrapper component. */}
+      <GlobalTooltip />
       <BrowserRouter>
         <DocumentTitle />
         <Routes>

client/src/components/Tip.tsx

@@ -4,6 +4,13 @@
  * by {@link StatCard} for raw metric values and anywhere a compact display needs
  * a full-precision expansion without cluttering the layout.
  *
+ * ## Look
+ * The bubble is {@link TOOLTIP_SURFACE} — the same surface the app-wide
+ * {@link GlobalTooltip} draws — so a raw-value tooltip and a control's tooltip
+ * are visibly one thing. It stays cursor-following (and not anchored like the
+ * global one) because it expands a NUMBER inside a line of text, where the
+ * anchor is a few characters wide and the cursor is the real subject.
+ *
  * ## Portal rendering
  * Tooltip content is portaled to `document.body` with `position: fixed` so
  * parent `overflow: hidden` cannot clip it. Placement flips left/up when the
@@ -56,6 +63,7 @@
 
 import { useState, useRef, useCallback } from "react";
 import { createPortal } from "react-dom";
+import { TOOLTIP_SURFACE } from "./Tooltip";
 
 /** Props for {@link Tip}. */
 interface TipProps {
@@ -135,11 +143,7 @@ export function Tip({ raw, children, maxWidth = 320, block = false }: TipProps)
       {children}
       {show &&
         createPortal(
-          <div
-            ref={tipRef}
-            style={tipStyle}
-            className="px-2.5 py-1.5 text-[11px] leading-relaxed font-mono text-fg-primary bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-xl pointer-events-none whitespace-pre-wrap break-words"
-          >
+          <div ref={tipRef} style={tipStyle} className={`${TOOLTIP_SURFACE} font-mono`}>
             {raw}
           </div>,
           document.body

client/src/components/Tooltip.tsx

@@ -0,0 +1,200 @@
+/**
+ * @file Tooltip.tsx
+ * @description The dashboard's tooltip look, and the one renderer that gives it
+ * to every control in the app.
+ *
+ * ## Why a global renderer instead of a wrapper component
+ * The UI already labels its icon-only controls with the native `title`
+ * attribute — over two hundred of them. A `<Tooltip>` wrapper would mean
+ * touching every one of those call sites to get a designed bubble, and the
+ * next `title=` someone writes would be back to the browser's grey box.
+ * {@link GlobalTooltip} instead listens once at the document: on hover or
+ * keyboard focus it takes the element's `title`, suppresses the native tooltip
+ * by removing the attribute for as long as the bubble is up, and restores it
+ * on the way out. Nothing else in the app has to know it exists, and a control
+ * keeps its native tooltip (and its accessible name) when JS has not run.
+ *
+ * ## The look
+ * Anchored to the CONTROL, not the cursor — a bubble that chases the mouse is
+ * hard to read and lands over the thing it describes. It flips above/below and
+ * clamps to the viewport, carries an arrow pointing at its anchor, fades in
+ * after a short delay so a cursor crossing a toolbar does not strobe, and is
+ * built from the theme's own tokens so it is legible in light mode too (the
+ * old bubble was a hardcoded near-black).
+ *
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+
+/** The shared bubble surface, so every tooltip in the app reads as one thing. */
+export const TOOLTIP_SURFACE =
+  "pointer-events-none z-[9999] max-w-xs rounded-lg border border-border bg-surface-2 px-2.5 py-1.5 " +
+  "text-[11px] leading-snug text-fg-primary shadow-lg shadow-black/20 " +
+  "whitespace-pre-wrap break-words";
+
+/** How long the pointer must rest on a control before its tooltip appears. */
+const SHOW_DELAY_MS = 350;
+/** Gap between the control and the bubble, and the minimum viewport margin. */
+const GAP = 8;
+
+/** Opt an element (or a subtree) out: `data-tip-off` keeps the native title. */
+const SELECTOR = "[title]:not([data-tip-off])";
+
+type Anchored = { text: string; rect: DOMRect };
+type Placed = { left: number; top: number; arrow: number; above: boolean };
+
+/**
+ * Mount ONCE, near the router root. Every `title` in the app becomes a
+ * designed tooltip; nothing else has to change.
+ */
+export function GlobalTooltip() {
+  const [tip, setTip] = useState<Anchored | null>(null);
+  const [pos, setPos] = useState<Placed | null>(null);
+  const bubble = useRef<HTMLDivElement>(null);
+  // The element whose `title` is currently parked in `data-tip`, so it can be
+  // put back even if the pointer never leaves it (a route change, a re-render
+  // that unmounts it, Escape).
+  const parked = useRef<HTMLElement | null>(null);
+  const timer = useRef<number | undefined>(undefined);
+
+  const restore = useCallback(() => {
+    window.clearTimeout(timer.current);
+    const el = parked.current;
+    if (el) {
+      const text = el.dataset.tip;
+      if (text !== undefined) {
+        el.setAttribute("title", text);
+        delete el.dataset.tip;
+      }
+      parked.current = null;
+    }
+    setTip(null);
+    setPos(null);
+  }, []);
+
+  const open = useCallback(
+    (el: HTMLElement, delay: number) => {
+      const text = (el.getAttribute("title") || "").trim();
+      if (!text) return;
+      restore();
+      timer.current = window.setTimeout(() => {
+        // Re-read at fire time: the control may have been re-rendered, removed
+        // or had its title changed while the delay was running.
+        if (!el.isConnected) return;
+        const current = (el.getAttribute("title") || "").trim();
+        if (!current) return;
+        el.dataset.tip = current;
+        el.removeAttribute("title");
+        parked.current = el;
+        setTip({ text: current, rect: el.getBoundingClientRect() });
+      }, delay);
+    },
+    [restore]
+  );
+
+  useEffect(() => {
+    const target = (e: Event) => {
+      const node = e.target;
+      return node instanceof Element ? (node.closest(SELECTOR) as HTMLElement | null) : null;
+    };
+    const onOver = (e: PointerEvent) => {
+      const el = target(e);
+      if (el) open(el, SHOW_DELAY_MS);
+    };
+    const onOut = (e: PointerEvent) => {
+      // Moving between children of the same control must not flicker.
+      const el = target(e);
+      const to = e.relatedTarget;
+      if (el && to instanceof Node && el.contains(to)) return;
+      if (el || parked.current) restore();
+    };
+    // Keyboard users get the same tooltip, immediately — a focus ring that
+    // reveals nothing is the whole reason icon-only buttons are hard to learn.
+    const onFocus = (e: FocusEvent) => {
+      const el = target(e);
+      if (el) open(el, 0);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") restore();
+    };
+
+    document.addEventListener("pointerover", onOver);
+    document.addEventListener("pointerout", onOut);
+    document.addEventListener("pointerdown", restore);
+    document.addEventListener("focusin", onFocus);
+    document.addEventListener("focusout", restore);
+    document.addEventListener("keydown", onKey);
+    // A bubble anchored to a rect is wrong the moment anything moves.
+    window.addEventListener("scroll", restore, true);
+    window.addEventListener("resize", restore);
+    return () => {
+      document.removeEventListener("pointerover", onOver);
+      document.removeEventListener("pointerout", onOut);
+      document.removeEventListener("pointerdown", restore);
+      document.removeEventListener("focusin", onFocus);
+      document.removeEventListener("focusout", restore);
+      document.removeEventListener("keydown", onKey);
+      window.removeEventListener("scroll", restore, true);
+      window.removeEventListener("resize", restore);
+      restore();
+    };
+  }, [open, restore]);
+
+  // Placed after the first paint, when the bubble's real size is known —
+  // measuring it is the only way to flip and clamp without guessing.
+  useEffect(() => {
+    if (!tip || !bubble.current) return;
+    const { width, height } = bubble.current.getBoundingClientRect();
+    const vw = document.documentElement.clientWidth;
+    const vh = window.innerHeight;
+    const centre = tip.rect.left + tip.rect.width / 2;
+
+    let left = centre - width / 2;
+    left = Math.min(Math.max(left, GAP), Math.max(GAP, vw - width - GAP));
+    // Below by default; above only when below would run off the screen AND
+    // above actually fits, so a control at the very bottom still gets a bubble.
+    const above = tip.rect.bottom + GAP + height > vh && tip.rect.top - height - GAP >= GAP;
+
+    setPos({
+      left,
+      top: above ? tip.rect.top - height - GAP : tip.rect.bottom + GAP,
+      // The arrow points at the control even after the bubble was clamped.
+      arrow: Math.min(Math.max(centre - left, 12), Math.max(12, width - 12)),
+      above,
+    });
+  }, [tip]);
+
+  if (!tip) return null;
+
+  return createPortal(
+    <div
+      ref={bubble}
+      role="tooltip"
+      data-testid="global-tooltip"
+      style={{
+        position: "fixed",
+        left: pos?.left ?? -9999,
+        top: pos?.top ?? -9999,
+        opacity: pos ? 1 : 0,
+        transition: "opacity 120ms ease-out",
+      }}
+      className={TOOLTIP_SURFACE}
+    >
+      {tip.text}
+      {/* Two borders only: a fully bordered diamond draws its other two
+          edges straight across the bubble it is attached to. */}
+      <span
+        aria-hidden
+        style={{ left: pos?.arrow ?? 0, [pos?.above ? "bottom" : "top"]: -4.5 }}
+        className={`absolute h-2 w-2 -translate-x-1/2 rotate-45 bg-surface-2 ${
+          pos?.above ? "border-b border-r" : "border-l border-t"
+        } border-border`}
+      />
+    </div>,
+    document.body
+  );
+}
+
+export default GlobalTooltip;

client/src/components/__tests__/Tooltip.test.tsx

@@ -0,0 +1,108 @@
+/**
+ * @file Tooltip.test.tsx
+ * @description Pins the app-wide tooltip renderer: a control's native `title`
+ * becomes the designed bubble on hover and on keyboard focus, the native
+ * tooltip is suppressed only while the bubble is up and the attribute is put
+ * back afterwards (it is the control's accessible name), and `data-tip-off`
+ * opts out.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { render, screen, fireEvent, act } from "@testing-library/react";
+import { GlobalTooltip } from "../Tooltip";
+
+function setup(extra?: React.ReactNode) {
+  return render(
+    <>
+      <GlobalTooltip />
+      <button title="Refresh the working copy">refresh</button>
+      {extra}
+    </>
+  );
+}
+
+const hover = (el: Element) => fireEvent.pointerOver(el, { bubbles: true });
+const unhover = (el: Element) => fireEvent.pointerOut(el, { bubbles: true });
+
+beforeEach(() => vi.useFakeTimers({ shouldAdvanceTime: true }));
+afterEach(() => vi.useRealTimers());
+
+const settle = async () => {
+  await act(async () => {
+    vi.advanceTimersByTime(400);
+  });
+};
+
+describe("GlobalTooltip", () => {
+  it("shows the bubble after a delay and takes the native title while it is up", async () => {
+    setup();
+    const button = screen.getByRole("button", { name: "refresh" });
+
+    hover(button);
+    // Nothing yet: a cursor crossing a toolbar must not strobe every control.
+    expect(screen.queryByTestId("global-tooltip")).toBeNull();
+
+    await settle();
+    expect(screen.getByTestId("global-tooltip")).toHaveTextContent("Refresh the working copy");
+    expect(button).not.toHaveAttribute("title");
+  });
+
+  it("hides and gives the title back on the way out", async () => {
+    setup();
+    const button = screen.getByRole("button", { name: "refresh" });
+    hover(button);
+    await settle();
+
+    unhover(button);
+    expect(screen.queryByTestId("global-tooltip")).toBeNull();
+    expect(button).toHaveAttribute("title", "Refresh the working copy");
+  });
+
+  it("opens immediately on keyboard focus and closes on Escape", async () => {
+    setup();
+    const button = screen.getByRole("button", { name: "refresh" });
+
+    fireEvent.focusIn(button);
+    await act(async () => {
+      vi.advanceTimersByTime(0);
+    });
+    expect(screen.getByTestId("global-tooltip")).toBeInTheDocument();
+
+    fireEvent.keyDown(document, { key: "Escape" });
+    expect(screen.queryByTestId("global-tooltip")).toBeNull();
+    expect(button).toHaveAttribute("title", "Refresh the working copy");
+  });
+
+  it("leaves a data-tip-off control on the browser's own tooltip", async () => {
+    setup(
+      <button title="Raw value" data-tip-off>
+        opted out
+      </button>
+    );
+    const opted = screen.getByRole("button", { name: "opted out" });
+
+    hover(opted);
+    await settle();
+    expect(screen.queryByTestId("global-tooltip")).toBeNull();
+    expect(opted).toHaveAttribute("title", "Raw value");
+  });
+
+  it("reads the title through a child element, and ignores an empty one", async () => {
+    setup(
+      <button title="">
+        <span data-testid="blank-child">blank</span>
+      </button>
+    );
+
+    hover(screen.getByTestId("blank-child"));
+    await settle();
+    expect(screen.queryByTestId("global-tooltip")).toBeNull();
+
+    const button = screen.getByRole("button", { name: "refresh" });
+    button.innerHTML = "<span data-testid='deep'>refresh</span>";
+    hover(screen.getByTestId("deep"));
+    await settle();
+    expect(screen.getByTestId("global-tooltip")).toHaveTextContent("Refresh the working copy");
+  });
+});

client/src/components/lanes/AddLaneModal.tsx

@@ -25,7 +25,19 @@ import { CwdAutocomplete } from "../run/RunSetup";
 import { FolderBrowseModal } from "./FolderBrowseModal";
 import { api } from "../../lib/api";
 import type { AiRouter, CwdSuggestion } from "../../lib/api";
-import type { Lane, LaneTool } from "../../lib/types";
+import type { Lane, LaneTool, LaneWorktree } from "../../lib/types";
+
+/** Mirrors server/lib/worktree.js `slugify`, for the branch-name PREVIEW only.
+ *  Nothing is sent from it: an empty branch field means "let the server name
+ *  it", which is how `LANE_BRANCH_PREFIX` keeps working. */
+function slugPreview(title: string) {
+  return title
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+}
 
 /** Polls the lane until the background `git worktree add` finishes (status
  *  leaves "provisioning"), or gives up after `timeoutMs`. Returns the final
@@ -77,11 +89,16 @@ export function AddLaneModal({
   onClose,
   onAdded,
   cwdSuggestions,
+  prefill,
 }: {
   open: boolean;
   onClose: () => void;
   /** Called with the newly created (possibly still-provisioning) lane. */
   onAdded: (lane: Lane) => void;
+  /** Fields to open with, for "new lane from this repo" in a lane's git bar.
+   *  A branch here means the sibling worktree checks out THAT branch, which
+   *  is the existing-branch mode — the reason that mode exists (issue #34). */
+  prefill?: { sourceRepo?: string; branch?: string } | null;
   /** The same suggestion list the Run form already fetched (dashboard cwd,
    *  home, recently-used paths) — reused rather than fetched a second time. */
   cwdSuggestions: CwdSuggestion[];
@@ -92,13 +109,17 @@ export function AddLaneModal({
   const [title, setTitle] = useState("");
   const [branch, setBranch] = useState("");
   const [branches, setBranches] = useState<string[] | null>(null);
+  const [worktrees, setWorktrees] = useState<LaneWorktree[]>([]);
+  // Two ways to start a worktree lane, and git's own rule decides which is
+  // possible: "new" forks a branch off `base`, "existing" checks out a branch
+  // that is already there — which git allows exactly once across all of a
+  // repo's worktrees, hence the busy markers below.
+  const [branchMode, setBranchMode] = useState<"new" | "existing">("new");
   const [base, setBase] = useState("");
-  const [pipeline, setPipeline] = useState("default");
   // "native" is the built-in profile, not a null state — see server/lib/ai-routers.js.
   const [router, setRouter] = useState("native");
   const [routers, setRouters] = useState<AiRouter[]>([]);
   const [routersLoaded, setRoutersLoaded] = useState(false);
-  const [pipelines, setPipelines] = useState<{ id: string; name: string; nodes: unknown[] }[]>([]);
   const [branchesError, setBranchesError] = useState<string | null>(null);
   const [tool, setTool] = useState<LaneTool>("claude");
   const [busy, setBusy] = useState(false);
@@ -117,8 +138,9 @@ export function AddLaneModal({
     setTitle("");
     setBranch("");
     setBranches(null);
+    setWorktrees([]);
+    setBranchMode("new");
     setBase("");
-    setPipeline("default");
     setRouter("native");
     setRoutersLoaded(false);
     setTool("claude");
@@ -128,23 +150,23 @@ export function AddLaneModal({
     setSetupResult(null);
   };
 
-  // The template a lane is created with is the ONLY chance to get it right
-  // from here: nothing else in the UI can change it afterwards, so a lane
-  // silently born on `default` renders an 8-node map for a 16-node workflow.
-  // Fetched on open (templates are file-backed and can change between opens).
+  // A prefill only ever seeds the fields ON OPEN: the user may then change
+  // anything, and re-applying it on every render would fight them for the box.
+  useEffect(() => {
+    if (!open || !prefill) return;
+    if (prefill.sourceRepo) setSourceRepo(prefill.sourceRepo);
+    if (prefill.branch) {
+      setBranch(prefill.branch);
+      setBranchMode("existing");
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open]);
+
+  // A session that boots on the vendor's API keeps talking to it for its whole
+  // life, so the router has to be picked here, before the lane exists.
   useEffect(() => {
     if (!open) return;
     let cancelled = false;
-    api.lanes
-      .pipelines()
-      .then((r) => {
-        if (!cancelled) setPipelines(r.pipelines);
-      })
-      .catch(() => {
-        // Quiet: the select just falls back to the single `default` option
-        // below, and the lane still gets created.
-        if (!cancelled) setPipelines([]);
-      });
     api.aiRouters
       .list()
       .then((r) => {
@@ -180,6 +202,7 @@ export function AddLaneModal({
     const path = sourceRepo.trim();
     if (!path) {
       setBranches(null);
+      setWorktrees([]);
       setBase("");
       setBranchesError(null);
       return;
@@ -190,6 +213,7 @@ export function AddLaneModal({
         const r = await api.lanes.branches(path);
         if (lookedUpFor.current !== path) return; // a newer path superseded this one
         setBranches(r.branches);
+        setWorktrees(r.worktrees || []);
         setBase(r.current || r.branches[0] || "");
         setBranchesError(null);
       } catch {
@@ -197,6 +221,7 @@ export function AddLaneModal({
         // Not yet a valid repo path (still being typed, or genuinely wrong) -
         // quiet by design, the same way CwdAutocomplete never errors either.
         setBranches(null);
+        setWorktrees([]);
         setBase("");
         setBranchesError(t("addLaneNotARepo"));
       }
@@ -220,7 +245,6 @@ export function AddLaneModal({
         const result = await api.lanes.ensure({
           cwd: repo,
           title: name || undefined,
-          pipeline,
           tool,
         });
         // Report the lane the INSTANT it exists server-side. Everything after
@@ -250,14 +274,17 @@ export function AddLaneModal({
       return;
     }
 
-    if (!branches || !name || !branch.trim()) return;
+    // A blank branch in "new" mode is legal and deliberate: the server names
+    // it `${LANE_BRANCH_PREFIX}${slug}`, which is what the placeholder previews.
+    if (!branches || !name || (branchMode === "existing" && !branch.trim())) return;
     try {
       const result = await api.lanes.worktree({
         sourceRepo: repo,
         title: name,
-        base: base || undefined,
-        branch: branch.trim(),
-        pipeline,
+        // An existing branch is checked out as it stands; `base` only means
+        // something when a branch is being forked.
+        base: branchMode === "new" ? base || undefined : undefined,
+        branch: branch.trim() || undefined,
         tool,
       });
       onAdded(result.lane);
@@ -348,7 +375,16 @@ export function AddLaneModal({
   const done = !!setupResult;
   const disabled =
     !done &&
-    (!sourceRepo.trim() || (mode === "worktree" && (!title.trim() || !branches || !branch.trim())));
+    (!sourceRepo.trim() ||
+      (mode === "worktree" &&
+        (!title.trim() || !branches || (branchMode === "existing" && !branch.trim()))));
+
+  /** branch name -> the worktree directory already holding it. git allows one
+   *  checkout per branch, so these are the branches this form cannot use. */
+  const busyBranches = new Map(
+    worktrees.filter((w) => w.branch).map((w) => [w.branch as string, w.path])
+  );
+  const freeBranches = (branches || []).filter((b) => !busyBranches.has(b));
 
   return (
     <ConfirmModal
@@ -422,6 +458,37 @@ export function AddLaneModal({
           </p>
         </div>
 
+        {/* What this repo already has checked out. Without it the form asked
+            for a branch in the dark: the one fact that decides whether a
+            branch can be used at all is which worktree is holding it. */}
+        {mode === "worktree" && worktrees.length > 0 && (
+          <div
+            data-testid="add-lane-worktrees"
+            className="rounded-md border border-border-light bg-surface-0 p-2"
+          >
+            <p className="mb-1 text-[10px] font-medium text-fg-secondary">
+              {t("addLaneWorktreesTitle", { count: worktrees.length })}
+            </p>
+            <ul className="space-y-0.5">
+              {worktrees.slice(0, 8).map((w) => (
+                <li key={w.path} className="flex items-baseline gap-1.5 text-[10px]">
+                  <span className="shrink-0 font-mono text-fg-primary">
+                    ⑂ {w.branch || t("addLaneWorktreeDetached")}
+                  </span>
+                  <span className="truncate text-fg-muted" title={w.path}>
+                    {w.path}
+                  </span>
+                </li>
+              ))}
+              {worktrees.length > 8 && (
+                <li className="text-[10px] text-fg-muted">
+                  {t("addLaneWorktreesMore", { count: worktrees.length - 8 })}
+                </li>
+              )}
+            </ul>
+          </div>
+        )}
+
         <div>
           <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-title">
             {t("addLaneTitleLabel")}
@@ -431,152 +498,215 @@ export function AddLaneModal({
             value={title}
             onChange={(e) => setTitle(e.target.value)}
             placeholder={t("addLaneTitlePlaceholder")}
-            className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary placeholder:text-fg-muted focus:border-blue-500 focus:outline-none"
+            className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary placeholder:text-fg-muted focus:border-accent focus:outline-none"
           />
         </div>
 
-        <div>
-          <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-pipeline">
-            {t("addLanePipelineLabel")}
-          </label>
-          <select
-            id="add-lane-pipeline"
-            value={pipeline}
-            onChange={(e) => setPipeline(e.target.value)}
-            className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary focus:border-blue-500 focus:outline-none"
-          >
-            {(pipelines.length ? pipelines : [{ id: "default", name: "default", nodes: [] }]).map(
-              (p) => (
-                <option key={p.id} value={p.id}>
-                  {p.nodes.length ? `${p.name} (${p.nodes.length})` : p.name}
-                </option>
-              )
-            )}
-          </select>
-          <p className="mt-1 text-[10px] text-fg-muted">{t("addLanePipelineHint")}</p>
-        </div>
-
-        <fieldset>
-          <legend className="mb-1 text-xs text-fg-secondary">{t("addLaneRouterLabel")}</legend>
-          <div className="flex gap-2">
-            {(
-              [
-                { value: "native", label: t("addLaneRouterNative") },
-                { value: "router", label: t("addLaneRouterCustom") },
-              ] as const
-            ).map((option) => {
-              const active = option.value === "native" ? router === "native" : router !== "native";
-              // Clicking "AI Router" before the list lands would resolve back to
-              // Native and read as a dead control.
-              const disabled = option.value === "router" && !routersLoaded;
-              return (
-                <label
-                  key={option.value}
-                  // No radio dot: the card itself lights up when selected. That
-                  // leaves the DISABLED state with nothing to show it, since the
-                  // greyed-out dot was carrying it — hence the explicit branch.
-                  // The input only goes visually hidden, so keyboard and screen
-                  // readers still get a real radio group, and the card carries
-                  // its focus ring.
-                  className={`block flex-1 rounded-lg border p-2.5 text-center text-xs shadow-sm transition-colors focus-within:ring-2 focus-within:ring-accent/50 ${
-                    disabled
-                      ? "cursor-not-allowed border-border bg-surface-2 text-fg-muted opacity-60"
-                      : active
-                        ? "cursor-pointer border-accent bg-accent/10 text-accent"
-                        : "cursor-pointer border-border bg-surface-2 text-fg-secondary hover:border-border-light hover:bg-surface-3"
-                  }`}
-                >
-                  <input
-                    type="radio"
-                    name="add-lane-router"
-                    className="sr-only"
-                    disabled={disabled}
-                    checked={active}
-                    onChange={() =>
-                      // Switching to "AI Router" lands on the first saved
-                      // profile; with none saved the radio stays on native and
-                      // the select below explains why.
-                      setRouter(
-                        option.value === "native"
-                          ? "native"
-                          : routers.find((r) => !r.builtin)?.name || "native"
-                      )
-                    }
-                  />
-                  {option.label}
-                </label>
-              );
-            })}
-          </div>
-
-          {router !== "native" && (
-            <select
-              aria-label={t("addLaneRouterProfileLabel")}
-              value={router}
-              onChange={(e) => setRouter(e.target.value)}
-              className="mt-2 w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary focus:border-blue-500 focus:outline-none"
-            >
-              {routers
-                .filter((r) => !r.builtin)
-                .map((r) => (
-                  <option key={r.name} value={r.name}>
-                    {r.label}
-                  </option>
-                ))}
-            </select>
-          )}
-          <p className="mt-1 text-[10px] text-fg-muted">
-            {!routersLoaded
-              ? t("addLaneRouterLoading")
-              : routers.some((r) => !r.builtin)
-                ? t("addLaneRouterHint")
-                : t("addLaneRouterEmptyHint")}
-          </p>
-        </fieldset>
-
-        {mode === "worktree" && branches && (
-          <div>
-            <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-base">
-              {t("addLaneBaseLabel")}
-            </label>
-            {branches.length === 0 ? (
-              <p className="text-[10px] text-fg-muted">{t("addLaneNoBranches")}</p>
-            ) : (
-              <select
-                id="add-lane-base"
-                value={base}
-                onChange={(e) => setBase(e.target.value)}
-                className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary focus:border-blue-500 focus:outline-none"
-              >
-                {branches.map((b) => (
-                  <option key={b} value={b}>
-                    {b}
-                  </option>
-                ))}
-              </select>
-            )}
-          </div>
-        )}
         {mode === "worktree" && branchesError && !branches && (
           <p className="text-[10px] text-status-warning">{branchesError}</p>
         )}
 
         {mode === "worktree" && branches && (
-          <div>
-            <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-branch">
-              {t("addLaneBranchLabel")}
-            </label>
-            <input
-              id="add-lane-branch"
-              value={branch}
-              onChange={(e) => setBranch(e.target.value)}
-              placeholder={t("addLaneBranchPlaceholder")}
-              className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 font-mono text-xs text-fg-primary placeholder:text-fg-muted focus:border-blue-500 focus:outline-none"
-            />
-            <p className="mt-1 text-[10px] text-fg-muted">{t("addLaneBranchHint")}</p>
+          <div data-testid="add-lane-branch-section" className="space-y-2">
+            <div className="flex items-center rounded-md border border-border bg-surface-2 p-0.5">
+              <Seg
+                active={branchMode === "new"}
+                label={t("addLaneBranchModeNew")}
+                onClick={() => {
+                  setBranchMode("new");
+                  setBranch("");
+                }}
+              />
+              <Seg
+                active={branchMode === "existing"}
+                label={t("addLaneBranchModeExisting")}
+                onClick={() => {
+                  setBranchMode("existing");
+                  // Land on something usable rather than on an empty select
+                  // that looks like a choice was already made.
+                  setBranch((current) =>
+                    freeBranches.includes(current) ? current : freeBranches[0] || ""
+                  );
+                }}
+              />
+              {/* The third answer to "which branch": none. A small or personal
+                  project usually wants the lane to BE the repo, working on
+                  whatever is checked out (`main`) — which is exactly Repo
+                  mode, so this jumps there rather than inventing a second way
+                  to do it. git cannot check `main` out in a second worktree
+                  while the repo itself holds it, so a worktree lane could not
+                  offer this even if it wanted to. */}
+              <Seg
+                active={false}
+                label={t("addLaneBranchModeCurrent")}
+                title={t("addLaneBranchModeCurrentHint")}
+                onClick={() => setMode("repo")}
+              />
+            </div>
+
+            {branchMode === "new" ? (
+              <>
+                <div>
+                  <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-base">
+                    {t("addLaneBaseLabel")}
+                  </label>
+                  {branches.length === 0 ? (
+                    <p className="text-[10px] text-fg-muted">{t("addLaneNoBranches")}</p>
+                  ) : (
+                    <select
+                      id="add-lane-base"
+                      value={base}
+                      onChange={(e) => setBase(e.target.value)}
+                      className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary focus:border-accent focus:outline-none"
+                    >
+                      {branches.map((b) => (
+                        <option key={b} value={b}>
+                          {b}
+                        </option>
+                      ))}
+                    </select>
+                  )}
+                </div>
+                <div>
+                  <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-branch">
+                    {t("addLaneBranchLabel")}
+                  </label>
+                  <input
+                    id="add-lane-branch"
+                    value={branch}
+                    onChange={(e) => setBranch(e.target.value)}
+                    // The placeholder is what the SERVER will name the branch
+                    // if this is left empty, so the default is visible without
+                    // the form having to duplicate LANE_BRANCH_PREFIX.
+                    placeholder={
+                      title.trim() ? `feat/${slugPreview(title)}` : t("addLaneBranchPlaceholder")
+                    }
+                    className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 font-mono text-xs text-fg-primary placeholder:text-fg-muted focus:border-accent focus:outline-none"
+                  />
+                  <p className="mt-1 text-[10px] text-fg-muted">{t("addLaneBranchHintAuto")}</p>
+                </div>
+              </>
+            ) : (
+              <div>
+                <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-existing">
+                  {t("addLaneBranchExistingLabel")}
+                </label>
+                {freeBranches.length === 0 ? (
+                  <p className="text-[10px] text-status-warning">{t("addLaneNoFreeBranches")}</p>
+                ) : (
+                  <select
+                    id="add-lane-existing"
+                    value={branch}
+                    onChange={(e) => setBranch(e.target.value)}
+                    className="w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 font-mono text-xs text-fg-primary focus:border-accent focus:outline-none"
+                  >
+                    {branches.map((b) => {
+                      const busyAt = busyBranches.get(b);
+                      return (
+                        // Disabled rather than hidden: "why is my branch not
+                        // in the list" is a worse question than seeing it
+                        // greyed out with the worktree that holds it.
+                        <option key={b} value={b} disabled={!!busyAt}>
+                          {busyAt ? t("addLaneBranchBusy", { branch: b, path: busyAt }) : b}
+                        </option>
+                      );
+                    })}
+                  </select>
+                )}
+                <p className="mt-1 text-[10px] text-fg-muted">{t("addLaneBranchExistingHint")}</p>
+              </div>
+            )}
           </div>
         )}
 
+        {/* The router is the one per-lane extra this form still asks for, so it
+            sits in the form itself — a disclosure around a single field only
+            hid it. The pipeline picker is gone entirely: every lane is created
+            on `default` (the server's own default) and the template is changed
+            from the lane's own header afterwards. */}
+        <div className="rounded-md border border-border-light bg-surface-0 p-2">
+          <div>
+            <fieldset>
+              <legend className="mb-1 text-xs text-fg-secondary">{t("addLaneRouterLabel")}</legend>
+              <div className="flex gap-2">
+                {(
+                  [
+                    { value: "native", label: t("addLaneRouterNative") },
+                    { value: "router", label: t("addLaneRouterCustom") },
+                  ] as const
+                ).map((option) => {
+                  const active =
+                    option.value === "native" ? router === "native" : router !== "native";
+                  // Clicking "AI Router" before the list lands would resolve back to
+                  // Native and read as a dead control.
+                  const disabled = option.value === "router" && !routersLoaded;
+                  return (
+                    <label
+                      key={option.value}
+                      // No radio dot: the card itself lights up when selected. That
+                      // leaves the DISABLED state with nothing to show it, since the
+                      // greyed-out dot was carrying it — hence the explicit branch.
+                      // The input only goes visually hidden, so keyboard and screen
+                      // readers still get a real radio group, and the card carries
+                      // its focus ring.
+                      className={`block flex-1 rounded-lg border p-2.5 text-center text-xs shadow-sm transition-colors focus-within:ring-2 focus-within:ring-accent/50 ${
+                        disabled
+                          ? "cursor-not-allowed border-border bg-surface-2 text-fg-muted opacity-60"
+                          : active
+                            ? "cursor-pointer border-accent bg-accent/10 text-accent"
+                            : "cursor-pointer border-border bg-surface-2 text-fg-secondary hover:border-border-light hover:bg-surface-3"
+                      }`}
+                    >
+                      <input
+                        type="radio"
+                        name="add-lane-router"
+                        className="sr-only"
+                        disabled={disabled}
+                        checked={active}
+                        onChange={() =>
+                          // Switching to "AI Router" lands on the first saved
+                          // profile; with none saved the radio stays on native and
+                          // the select below explains why.
+                          setRouter(
+                            option.value === "native"
+                              ? "native"
+                              : routers.find((r) => !r.builtin)?.name || "native"
+                          )
+                        }
+                      />
+                      {option.label}
+                    </label>
+                  );
+                })}
+              </div>
+
+              {router !== "native" && (
+                <select
+                  aria-label={t("addLaneRouterProfileLabel")}
+                  value={router}
+                  onChange={(e) => setRouter(e.target.value)}
+                  className="mt-2 w-full rounded-md border border-border-light bg-surface-0 px-3 py-1.5 text-xs text-fg-primary focus:border-accent focus:outline-none"
+                >
+                  {routers
+                    .filter((r) => !r.builtin)
+                    .map((r) => (
+                      <option key={r.name} value={r.name}>
+                        {r.label}
+                      </option>
+                    ))}
+                </select>
+              )}
+              <p className="mt-1 text-[10px] text-fg-muted">
+                {!routersLoaded
+                  ? t("addLaneRouterLoading")
+                  : routers.some((r) => !r.builtin)
+                    ? t("addLaneRouterHint")
+                    : t("addLaneRouterEmptyHint")}
+              </p>
+            </fieldset>
+          </div>
+        </div>
+
         {setupResult && (
           <div className="rounded-md border border-border-light bg-surface-0 p-2 space-y-1">
             <p className="text-[10px] font-medium text-fg-secondary">{t("addLaneSetupTitle")}</p>

client/src/components/lanes/LaneCard.tsx

@@ -24,6 +24,7 @@ import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
 import { DestructiveLaneModal } from "./DestructiveLaneModal";
+import { LaneGitBar } from "./LaneGitBar";
 import { api } from "../../lib/api";
 import { eventBus } from "../../lib/eventBus";
 import { keepIfSame } from "../../lib/keepIfSame";
@@ -49,8 +50,11 @@ const LOCKS_REFRESH_MS = 30_000;
  * polled lane list. Absent facts are not an error state: a lane may point at a
  * plain directory, and it renders as a card without a git row.
  */
-function useLaneGitFacts(laneId: number): LaneGitFacts | null {
+function useLaneGitFacts(laneId: number): [LaneGitFacts | null, () => void] {
   const [facts, setFacts] = useState<LaneGitFacts | null>(null);
+  // Bumped by the git action bar: a commit or a pull changes every fact on
+  // this row, and waiting out the 30s poll makes the button look inert.
+  const [nonce, setNonce] = useState(0);
 
   useEffect(() => {
     let alive = true;
@@ -72,9 +76,9 @@ function useLaneGitFacts(laneId: number): LaneGitFacts | null {
       alive = false;
       clearInterval(timer);
     };
-  }, [laneId]);
+  }, [laneId, nonce]);
 
-  return facts;
+  return [facts, () => setNonce((n) => n + 1)];
 }
 
 /**
@@ -609,6 +613,7 @@ export default function LaneCard({
   onAction,
   childWorktrees,
   onSelectLane,
+  onNewLaneFromRepo,
 }: {
   lane: Lane;
   onAction: (action: string, body?: Record<string, unknown>) => void;
@@ -618,6 +623,9 @@ export default function LaneCard({
   childWorktrees?: Lane[];
   /** Jumps the Workspace page's selection to another lane's card. */
   onSelectLane?: (id: number) => void;
+  /** Opens the Add-lane flow prefilled with this lane's repo, for a sibling
+   *  worktree on `branch`. Omitted where that flow is not reachable. */
+  onNewLaneFromRepo?: (repo: string, branch?: string) => void;
 }) {
   const { t } = useTranslation(["lanes"]);
   const [destructiveAction, setDestructiveAction] = useState<"reset" | null>(null);
@@ -639,7 +647,7 @@ export default function LaneCard({
     filesCloseTimer.current = window.setTimeout(() => setFilesOpen(false), 150);
   }, []);
   useEffect(() => () => window.clearTimeout(filesCloseTimer.current), []);
-  const git = useLaneGitFacts(lane.id);
+  const [git, refreshGit] = useLaneGitFacts(lane.id);
   const runtime = useLaneRuntime(lane.id, runtimeBump);
   const locks = useLaneLocks(lane.slot);
 
@@ -809,6 +817,21 @@ export default function LaneCard({
             )}
           </div>
         )}
+        {git?.available && (
+          <LaneGitBar
+            laneId={lane.id}
+            git={git}
+            onChanged={refreshGit}
+            /* A sibling worktree forks from the lane's SOURCE repo when it
+               has one (this lane is itself a worktree of it); an adopted lane
+               is its own repo. */
+            onNewLane={
+              onNewLaneFromRepo
+                ? (branch) => onNewLaneFromRepo(lane.source_repo || lane.cwd, branch)
+                : undefined
+            }
+          />
+        )}
         {/* The lane's own recorded branch, shown only when git could not be
             read — otherwise it duplicates the live branch above. */}
         {!git?.available && lane.branch && (

client/src/components/lanes/LaneChangesPanel.tsx

@@ -0,0 +1,905 @@
+/**
+ * @file The Changes panel: the lane's code beside its console, in the five
+ * shapes a review actually needs —
+ *
+ *   overview — every changed file with its +/- counts and its stage/discard
+ *              actions; click one to open it
+ *   review   — every file's full diff, stacked, for reading a whole change-set
+ *   file     — one file, as a diff or as its whole content (issue #35)
+ *   history  — recent commits; opening one shows that commit's diff
+ *   browse   — quick-open by path, or the repo's tracked file tree
+ *
+ * and three ranges: `work` (uncommitted, what the agent has touched right
+ * now), `branch` (`base...HEAD`, what this lane adds on top of its base) and
+ * `commit` (one commit, reached from history).
+ *
+ * Only the overview polls. Review, file, history and browse are a deliberate
+ * read of a frozen moment — re-fetching under the reader's scroll position is
+ * worse than a slightly stale view, and those are the expensive shapes.
+ *
+ * Rendering lives in LaneDiffView.tsx. Every write goes through
+ * `POST /api/lanes/:id/git/:action`, and `discard` is asked for twice here
+ * before the server is told `confirm: true` — it is the one action in this
+ * panel git cannot undo.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+  ChevronDown,
+  ChevronLeft,
+  ChevronRight,
+  ChevronsDownUp,
+  ChevronsUpDown,
+  Columns2,
+  FileText,
+  FoldVertical,
+  Folder,
+  Minus,
+  Plus,
+  RefreshCw,
+  Rows3,
+  Trash2,
+  UnfoldVertical,
+} from "lucide-react";
+import { api } from "../../lib/api";
+import { LaneDiffView, LaneFileView, type DiffLayout } from "./LaneDiffView";
+import type {
+  LaneChangeFile,
+  LaneChangeRange,
+  LaneChanges,
+  LaneCommit,
+  LaneTreeEntry,
+} from "../../lib/types";
+
+/** How often the overview re-reads. Summary only — no patch text. */
+const OVERVIEW_REFRESH_MS = 15_000;
+/** Context steps the expand button walks through, then the whole file. */
+const CONTEXT_STEPS: readonly [number, ...number[]] = [3, 12, 40, 5000];
+
+const LAST_CONTEXT = CONTEXT_STEPS[CONTEXT_STEPS.length - 1]!;
+
+type Mode = "overview" | "review" | "file" | "history" | "browse";
+
+/** Colour per porcelain status letter, matching LaneCard's file panel. */
+function statusClass(status: string, untracked: boolean) {
+  if (untracked) return "text-status-success";
+  const code = status.trim()[0];
+  if (code === "A") return "text-status-success";
+  if (code === "D") return "text-status-danger";
+  if (code === "R") return "text-accent";
+  return "text-status-warning";
+}
+
+/** `+12 −3`, with the halves coloured and a zero side dropped. A binary file
+ *  has no line delta at all, so it says `bin` rather than leaving the row's
+ *  right edge blank, which reads as "changed by nothing". */
+function Delta({
+  added,
+  deleted,
+  binary,
+}: {
+  added: number | null;
+  deleted: number | null;
+  binary?: boolean;
+}) {
+  const { t } = useTranslation(["lanes"]);
+  if (binary)
+    return <span className="shrink-0 font-mono text-[10px] text-fg-muted">{t("changes.bin")}</span>;
+  return (
+    <span className="shrink-0 font-mono text-[10px]">
+      {added ? <span className="text-status-success">+{added}</span> : null}
+      {added && deleted ? " " : null}
+      {deleted ? <span className="text-status-danger">−{deleted}</span> : null}
+    </span>
+  );
+}
+
+/**
+ * One folder level of the browse tree, rendered in place and recursing into
+ * every expanded child — so opening a nested file no longer means navigating
+ * away from its siblings.
+ */
+function TreeNodes({
+  path,
+  depth,
+  children,
+  expanded,
+  onToggleDir,
+  onOpenFile,
+}: {
+  path: string;
+  depth: number;
+  children: Record<string, LaneTreeEntry[]>;
+  expanded: Set<string>;
+  onToggleDir: (path: string) => void;
+  onOpenFile: (path: string) => void;
+}) {
+  const entries = children[path];
+  if (!entries) return null;
+  return (
+    <>
+      {entries.map((e) => (
+        <li key={e.path}>
+          <button
+            type="button"
+            onClick={() => (e.dir ? onToggleDir(e.path) : onOpenFile(e.path))}
+            style={{ paddingLeft: `${depth * 0.9 + 0.25}rem` }}
+            className="flex w-full items-center gap-1 rounded px-1 py-0.5 text-left font-mono text-[11px] text-fg-primary hover:bg-surface-2"
+          >
+            {e.dir ? (
+              expanded.has(e.path) ? (
+                <ChevronDown className="h-3 w-3 shrink-0 text-fg-muted" />
+              ) : (
+                <ChevronRight className="h-3 w-3 shrink-0 text-fg-muted" />
+              )
+            ) : (
+              <span className="w-3 shrink-0" />
+            )}
+            {e.dir ? (
+              <Folder className="h-3 w-3 shrink-0 text-accent" />
+            ) : (
+              <FileText className="h-3 w-3 shrink-0 text-fg-muted" />
+            )}
+            <span className="min-w-0 flex-1 truncate">{e.name}</span>
+          </button>
+          {e.dir && expanded.has(e.path) && (
+            <ul>
+              <TreeNodes
+                path={e.path}
+                depth={depth + 1}
+                children={children}
+                expanded={expanded}
+                onToggleDir={onToggleDir}
+                onOpenFile={onOpenFile}
+              />
+            </ul>
+          )}
+        </li>
+      ))}
+    </>
+  );
+}
+
+function IconButton({
+  label,
+  onClick,
+  disabled,
+  danger,
+  children,
+}: {
+  label: string;
+  onClick: () => void;
+  disabled?: boolean;
+  danger?: boolean;
+  children: React.ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      aria-label={label}
+      title={label}
+      className={`shrink-0 rounded p-0.5 disabled:opacity-40 ${
+        danger ? "text-fg-muted hover:text-status-danger" : "text-fg-muted hover:text-fg-primary"
+      }`}
+    >
+      {children}
+    </button>
+  );
+}
+
+export function LaneChangesPanel({ laneId }: { laneId: number }) {
+  const { t } = useTranslation(["lanes"]);
+  const [range, setRange] = useState<LaneChangeRange>("work");
+  const [mode, setMode] = useState<Mode>("overview");
+  const [openFile, setOpenFile] = useState<string | null>(null);
+  const [sha, setSha] = useState<string | null>(null);
+  const [context, setContext] = useState(CONTEXT_STEPS[0]);
+  const [layout, setLayout] = useState<DiffLayout>("unified");
+  const [whole, setWhole] = useState(false);
+  const [data, setData] = useState<LaneChanges | null>(null);
+  const [commits, setCommits] = useState<LaneCommit[] | null>(null);
+  // A folder's children, keyed by its path ("" is the root) — fetched once,
+  // on first expand, and kept so re-collapsing doesn't re-fetch.
+  const [treeChildren, setTreeChildren] = useState<Record<string, LaneTreeEntry[]>>({});
+  const [expandedDirs, setExpandedDirs] = useState<Set<string>>(new Set());
+  const [query, setQuery] = useState("");
+  const [hits, setHits] = useState<string[] | null>(null);
+  const [text, setText] = useState<{ path: string; lines: string[]; truncated: boolean } | null>(
+    null
+  );
+  const [loading, setLoading] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [confirmDiscard, setConfirmDiscard] = useState<string | null>(null);
+  // Files folded shut in review mode. A change-set is read file by file, and
+  // a file already read is in the way of the next one — so the set is what is
+  // COLLAPSED, and a file arriving later is open by default.
+  const [collapsed, setCollapsed] = useState<Set<string>>(new Set());
+  // Where opening a file came FROM: its mode and how far the list was scrolled.
+  // Reviewing a change-set is a walk down a long list, and landing back at the
+  // top of it after every file is the whole cost of opening one.
+  const scroller = useRef<HTMLDivElement>(null);
+  const returnTo = useRef<{ mode: Mode; scroll: number } | null>(null);
+  const pendingScroll = useRef<number | null>(null);
+  const [message, setMessage] = useState("");
+  const [error, setError] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const result = await api.lanes.changes(laneId, {
+        range,
+        ...(range === "commit" && sha ? { sha } : {}),
+        ...(mode === "file" && openFile ? { path: openFile, context } : {}),
+        ...(mode === "review" ? { full: true } : {}),
+      });
+      setData(result);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setLoading(false);
+    }
+  }, [laneId, range, sha, mode, openFile, context]);
+
+  useEffect(() => {
+    if (mode === "history" || mode === "browse") return;
+    void load();
+    // Only the cheap shape polls; see the file header.
+    if (mode !== "overview") return;
+    const timer = window.setInterval(() => void load(), OVERVIEW_REFRESH_MS);
+    return () => window.clearInterval(timer);
+  }, [load, mode]);
+
+  // History and the file tree are their own reads, each fetched when its mode
+  // is entered rather than alongside the diff nobody is looking at.
+  useEffect(() => {
+    if (mode !== "history") return;
+    void api.lanes
+      .gitLog(laneId, { limit: 50 })
+      .then((r) => setCommits(r.commits))
+      .catch((err) => setError(err instanceof Error ? err.message : String(err)));
+  }, [mode, laneId]);
+
+  useEffect(() => {
+    if (mode !== "browse" || query.trim() || "" in treeChildren) return;
+    void api.lanes
+      .gitTree(laneId, "")
+      .then((r) => setTreeChildren((prev) => ({ ...prev, "": r.entries })))
+      .catch((err) => setError(err instanceof Error ? err.message : String(err)));
+    // `treeChildren` is the cache this fills — reading it as a dep would loop.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [mode, laneId, query]);
+
+  // A folder's children are fetched lazily, the first time it is expanded.
+  const toggleDir = (path: string) => {
+    setExpandedDirs((prev) => {
+      const next = new Set(prev);
+      if (!next.delete(path)) next.add(path);
+      return next;
+    });
+    if (path in treeChildren) return;
+    void api.lanes
+      .gitTree(laneId, path)
+      .then((r) => setTreeChildren((prev) => ({ ...prev, [path]: r.entries })))
+      .catch((err) => setError(err instanceof Error ? err.message : String(err)));
+  };
+
+  const [treeBusy, setTreeBusy] = useState(false);
+
+  // Fetches whatever level isn't cached yet, depth-first, so "expand all"
+  // works even on a tree nothing has been opened in.
+  const expandAllDirs = async () => {
+    setTreeBusy(true);
+    const cache = { ...treeChildren };
+    const toExpand = new Set(expandedDirs);
+    const walk = async (path: string) => {
+      let entries = cache[path];
+      if (!entries) {
+        entries = (await api.lanes.gitTree(laneId, path)).entries;
+        cache[path] = entries;
+      }
+      const dirs = entries.filter((e) => e.dir);
+      for (const d of dirs) toExpand.add(d.path);
+      await Promise.all(dirs.map((d) => walk(d.path)));
+    };
+    try {
+      await walk("");
+      setTreeChildren(cache);
+      setExpandedDirs(toExpand);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setTreeBusy(false);
+    }
+  };
+
+  useEffect(() => {
+    const q = query.trim();
+    if (mode !== "browse" || !q) {
+      setHits(null);
+      return;
+    }
+    const timer = window.setTimeout(() => {
+      void api.lanes
+        .gitLs(laneId, q)
+        .then((r) => setHits(r.paths))
+        .catch(() => setHits([]));
+    }, 150);
+    return () => window.clearTimeout(timer);
+  }, [mode, laneId, query]);
+
+  // The whole-file read is a different endpoint from the diff, so it is its
+  // own fetch — and only while the viewer is actually showing it.
+  useEffect(() => {
+    if (mode !== "file" || !whole || !openFile) return;
+    void api.lanes
+      .gitFile(laneId, openFile, range === "commit" && sha ? sha : "work")
+      .then((r) =>
+        setText(r.available ? { path: r.path, lines: r.lines, truncated: r.truncated } : null)
+      )
+      .catch((err) => setError(err instanceof Error ? err.message : String(err)));
+  }, [mode, whole, openFile, laneId, range, sha]);
+
+  // A lane switch must not leave the previous lane's file open — its path
+  // almost certainly does not exist in the new one.
+  useEffect(() => {
+    setMode("overview");
+    setOpenFile(null);
+    setSha(null);
+    setRange("work");
+    setTreeChildren({});
+    setExpandedDirs(new Set());
+    setCommits(null);
+    setCollapsed(new Set());
+    returnTo.current = null;
+    pendingScroll.current = null;
+  }, [laneId]);
+
+  // Restoring has to wait for the list to be TALL enough again: leaving a file
+  // re-fetches the mode it came from, so the first render back is an empty
+  // box that would swallow the scroll.
+  useLayoutEffect(() => {
+    const el = scroller.current;
+    const want = pendingScroll.current;
+    if (mode === "file" || want == null || !el) return;
+    if (el.scrollHeight - el.clientHeight < want) return;
+    el.scrollTop = want;
+    pendingScroll.current = null;
+  }, [mode, data]);
+
+  const show = (path: string) => {
+    // Opening a file FROM a file (the review list is gone by then) must not
+    // overwrite the list position that is still waiting to be restored.
+    if (mode !== "file") {
+      returnTo.current = { mode, scroll: scroller.current?.scrollTop ?? 0 };
+    }
+    setOpenFile(path);
+    setContext(CONTEXT_STEPS[0]);
+    setWhole(false);
+    setText(null);
+    setMode("file");
+  };
+
+  const act = async (action: "stage" | "unstage" | "discard", path: string, confirm?: boolean) => {
+    setBusy(true);
+    setError(null);
+    try {
+      await api.lanes.gitAction(laneId, action, { paths: [path], ...(confirm ? { confirm } : {}) });
+      setConfirmDiscard(null);
+      await load();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const commitStaged = async () => {
+    setBusy(true);
+    setError(null);
+    try {
+      // `only: "staged"` — the whole point of staging file by file is that the
+      // commit takes the index as it stands, with no `add -A` sweeping the
+      // rest of the tree in behind it.
+      await api.lanes.gitAction(laneId, "commit", { message: message.trim(), only: "staged" });
+      setMessage("");
+      await load();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const toggleCollapsed = (path: string) =>
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (!next.delete(path)) next.add(path);
+      return next;
+    });
+
+  const files = data?.available ? data.files : [];
+  const allCollapsed = files.length > 0 && files.every((f) => collapsed.has(f.path));
+  const stagedCount = range === "work" ? files.filter((f) => f.staged).length : 0;
+  const current = mode === "file" ? files.find((f) => f.path === openFile) : undefined;
+
+  const Row = ({ f }: { f: LaneChangeFile }) => (
+    <li className="group flex items-baseline gap-1">
+      <button
+        type="button"
+        onClick={() => show(f.path)}
+        className="flex min-w-0 flex-1 items-baseline gap-1.5 rounded px-1 py-0.5 text-left hover:bg-surface-2"
+      >
+        <span
+          className={`w-3 shrink-0 font-mono text-[11px] font-semibold ${statusClass(
+            f.status,
+            f.untracked
+          )}`}
+        >
+          {f.untracked ? "A" : f.status.trim()[0] || "M"}
+        </span>
+        <span
+          className="min-w-0 flex-1 truncate font-mono text-[11px] text-fg-primary"
+          title={f.path}
+        >
+          {f.path}
+        </span>
+        {f.conflicted && (
+          <span className="shrink-0 text-[10px] text-status-danger">{t("changes.conflicted")}</span>
+        )}
+        <Delta added={f.added} deleted={f.deleted} binary={f.binary} />
+      </button>
+      {range === "work" && (
+        <span className="flex shrink-0 items-center gap-0.5">
+          {f.staged ? (
+            <IconButton
+              label={t("changes.unstage")}
+              disabled={busy}
+              onClick={() => void act("unstage", f.path)}
+            >
+              <Minus className="h-3 w-3" />
+            </IconButton>
+          ) : null}
+          {f.unstaged || f.untracked ? (
+            <IconButton
+              label={t("changes.stage")}
+              disabled={busy}
+              onClick={() => void act("stage", f.path)}
+            >
+              <Plus className="h-3 w-3" />
+            </IconButton>
+          ) : null}
+          <IconButton
+            label={confirmDiscard === f.path ? t("changes.discardConfirm") : t("changes.discard")}
+            disabled={busy}
+            danger
+            onClick={() => {
+              // Two clicks, always: the first arms the row, the second is the
+              // only one that reaches the server (which itself refuses the
+              // call without `confirm: true`).
+              if (confirmDiscard === f.path) void act("discard", f.path, true);
+              else setConfirmDiscard(f.path);
+            }}
+          >
+            <Trash2
+              className={`h-3 w-3 ${confirmDiscard === f.path ? "text-status-danger" : ""}`}
+            />
+          </IconButton>
+        </span>
+      )}
+    </li>
+  );
+
+  return (
+    <div data-testid="lane-changes" className="flex min-h-0 flex-1 flex-col">
+      {/* Two rows on purpose: WHERE you are (mode, and the refresh that always
+          applies) on top, HOW you are looking at it (range, layout, context,
+          whole file) underneath. One row wrapped mid-group as soon as the
+          panel was narrow, which is every panel beside a console. */}
+      <div className="mb-2 space-y-1.5">
+        <div className="flex items-center gap-1.5">
+          {mode === "file" ? (
+            <button
+              type="button"
+              onClick={() => {
+                const back = returnTo.current;
+                pendingScroll.current = back?.scroll ?? 0;
+                returnTo.current = null;
+                setMode(back?.mode ?? (range === "commit" ? "review" : "overview"));
+                setOpenFile(null);
+                setWhole(false);
+              }}
+              className="flex items-center gap-0.5 rounded border border-border-light px-1.5 py-0.5 text-[11px] text-fg-secondary hover:bg-surface-2"
+            >
+              <ChevronLeft className="h-3 w-3" />
+              {t("changes.back")}
+            </button>
+          ) : (
+            <div className="flex min-w-0 items-center rounded border border-border bg-surface-2 p-0.5">
+              {(["browse", "overview", "review", "history"] as const).map((m) => (
+                <button
+                  key={m}
+                  type="button"
+                  aria-pressed={mode === m}
+                  onClick={() => setMode(m)}
+                  className={`rounded px-2 py-0.5 text-[11px] font-medium transition-colors ${
+                    mode === m
+                      ? "bg-accent text-white"
+                      : "text-fg-secondary hover:bg-surface-3 hover:text-fg-primary"
+                  }`}
+                >
+                  {t(`changes.mode.${m}`)}
+                </button>
+              ))}
+            </div>
+          )}
+
+          <button
+            type="button"
+            onClick={() => void load()}
+            aria-label={t("changes.refresh")}
+            title={t("changes.refresh")}
+            className="ml-auto shrink-0 text-fg-muted hover:text-fg-primary"
+          >
+            <RefreshCw className={`h-3.5 w-3.5 ${loading ? "animate-spin" : ""}`} />
+          </button>
+        </div>
+
+        {mode !== "history" && mode !== "browse" && (
+          <div className="flex flex-wrap items-center gap-1.5">
+            <div className="flex items-center rounded border border-border bg-surface-2 p-0.5">
+              {(["work", "branch"] as const).map((r) => (
+                <button
+                  key={r}
+                  type="button"
+                  aria-pressed={range === r}
+                  onClick={() => {
+                    setRange(r);
+                    setSha(null);
+                  }}
+                  title={t(`changes.range.${r}Hint`)}
+                  className={`rounded px-2 py-0.5 text-[11px] transition-colors ${
+                    range === r
+                      ? "bg-surface-4 text-fg-primary"
+                      : "text-fg-secondary hover:text-fg-primary"
+                  }`}
+                >
+                  {t(`changes.range.${r}`)}
+                </button>
+              ))}
+              {range === "commit" && sha && (
+                <span
+                  data-testid="lane-changes-commit-chip"
+                  className="rounded bg-surface-4 px-2 py-0.5 font-mono text-[11px] text-fg-primary"
+                >
+                  {sha.slice(0, 7)}
+                </span>
+              )}
+            </div>
+
+            {(mode === "file" || mode === "review") && (
+              <div className="flex items-center gap-0.5 rounded border border-border bg-surface-2 p-0.5">
+                {mode === "review" && (
+                  <IconButton
+                    label={allCollapsed ? t("changes.expandAll") : t("changes.collapseAll")}
+                    disabled={files.length === 0}
+                    onClick={() =>
+                      setCollapsed(allCollapsed ? new Set() : new Set(files.map((f) => f.path)))
+                    }
+                  >
+                    {allCollapsed ? (
+                      <ChevronsUpDown className="h-3.5 w-3.5" />
+                    ) : (
+                      <ChevronsDownUp className="h-3.5 w-3.5" />
+                    )}
+                  </IconButton>
+                )}
+                <IconButton
+                  label={t(`changes.layout.${layout === "unified" ? "split" : "unified"}`)}
+                  onClick={() => setLayout(layout === "unified" ? "split" : "unified")}
+                >
+                  {layout === "unified" ? (
+                    <Columns2 className="h-3.5 w-3.5" />
+                  ) : (
+                    <Rows3 className="h-3.5 w-3.5" />
+                  )}
+                </IconButton>
+                {mode === "file" && (
+                  <>
+                    {/* Context walks BOTH ways: an expanded diff that cannot
+                        be collapsed again leaves the reader re-opening the
+                        file to get the tight view back. */}
+                    <IconButton
+                      label={t("changes.collapseContext")}
+                      disabled={whole || context <= CONTEXT_STEPS[0]}
+                      onClick={() =>
+                        setContext(
+                          [...CONTEXT_STEPS].reverse().find((step) => step < context) ??
+                            CONTEXT_STEPS[0]
+                        )
+                      }
+                    >
+                      <FoldVertical className="h-3.5 w-3.5" />
+                    </IconButton>
+                    <IconButton
+                      label={t("changes.expandContext")}
+                      disabled={whole || context >= LAST_CONTEXT}
+                      onClick={() => setContext(CONTEXT_STEPS.find((s) => s > context) ?? context)}
+                    >
+                      <UnfoldVertical className="h-3.5 w-3.5" />
+                    </IconButton>
+                  </>
+                )}
+              </div>
+            )}
+
+            {mode === "file" && (
+              <button
+                type="button"
+                aria-pressed={whole}
+                onClick={() => setWhole(!whole)}
+                className={`rounded border border-border-light px-1.5 py-0.5 text-[11px] ${
+                  whole ? "bg-surface-4 text-fg-primary" : "text-fg-secondary hover:bg-surface-2"
+                }`}
+              >
+                {t("changes.wholeFile")}
+              </button>
+            )}
+          </div>
+        )}
+      </div>
+
+      {error && (
+        <p role="alert" className="mb-2 whitespace-pre-wrap text-[11px] text-status-danger">
+          {error}
+        </p>
+      )}
+
+      {/* In single-file mode the DIFF owns the scrolling, so its horizontal
+          bar sits at the bottom of the visible box instead of at the bottom of
+          a 2000-line container nobody has scrolled to yet. Every other mode is
+          a list, and a list scrolls here. */}
+      <div
+        ref={scroller}
+        data-testid="lane-changes-body"
+        className={`flex min-h-0 flex-1 flex-col ${
+          mode === "file" ? "overflow-hidden" : "overflow-y-auto"
+        }`}
+      >
+        {mode === "history" ? (
+          <ul data-testid="lane-changes-history" className="space-y-0.5">
+            {(commits ?? []).map((c) => (
+              <li key={c.sha}>
+                <button
+                  type="button"
+                  onClick={() => {
+                    setSha(c.sha);
+                    setRange("commit");
+                    setMode("review");
+                  }}
+                  className="w-full rounded px-1 py-0.5 text-left hover:bg-surface-2"
+                >
+                  <span className="flex items-baseline gap-1.5">
+                    <span className="shrink-0 font-mono text-[10px] text-fg-muted">{c.short}</span>
+                    <span className="min-w-0 flex-1 truncate text-[11px] text-fg-primary">
+                      {c.subject}
+                    </span>
+                  </span>
+                  <span className="flex items-baseline gap-1.5 pl-[3.2rem] text-[10px] text-fg-muted">
+                    <span className="truncate">{c.author}</span>
+                    <span>{new Date(c.date).toLocaleString()}</span>
+                  </span>
+                </button>
+              </li>
+            ))}
+            {commits && commits.length === 0 && (
+              <li className="text-[11px] text-fg-muted">{t("changes.noCommits")}</li>
+            )}
+          </ul>
+        ) : mode === "browse" ? (
+          <div data-testid="lane-changes-browse">
+            <div className="mb-2 flex items-center gap-1.5">
+              <input
+                value={query}
+                onChange={(e) => setQuery(e.target.value)}
+                placeholder={t("changes.quickOpen")}
+                aria-label={t("changes.quickOpen")}
+                className="w-full rounded border border-border bg-surface-1 px-2 py-1 font-mono text-[11px] text-fg-primary"
+              />
+              {!hits && (
+                <IconButton
+                  label={
+                    expandedDirs.size > 0
+                      ? t("changes.collapseAllFolders")
+                      : t("changes.expandAllFolders")
+                  }
+                  disabled={treeBusy}
+                  onClick={() =>
+                    expandedDirs.size > 0 ? setExpandedDirs(new Set()) : void expandAllDirs()
+                  }
+                >
+                  {expandedDirs.size > 0 ? (
+                    <ChevronsDownUp className="h-3.5 w-3.5" />
+                  ) : (
+                    <ChevronsUpDown className="h-3.5 w-3.5" />
+                  )}
+                </IconButton>
+              )}
+            </div>
+            {hits ? (
+              <ul className="space-y-0.5">
+                {hits.map((p) => (
+                  <li key={p}>
+                    <button
+                      type="button"
+                      onClick={() => {
+                        show(p);
+                        setWhole(true);
+                      }}
+                      className="w-full truncate rounded px-1 py-0.5 text-left font-mono text-[11px] text-fg-primary hover:bg-surface-2"
+                    >
+                      {p}
+                    </button>
+                  </li>
+                ))}
+                {hits.length === 0 && (
+                  <li className="text-[11px] text-fg-muted">{t("changes.noMatches")}</li>
+                )}
+              </ul>
+            ) : (
+              <ul className="space-y-0.5">
+                <TreeNodes
+                  path=""
+                  depth={0}
+                  children={treeChildren}
+                  expanded={expandedDirs}
+                  onToggleDir={toggleDir}
+                  onOpenFile={(p) => {
+                    show(p);
+                    setWhole(true);
+                  }}
+                />
+              </ul>
+            )}
+          </div>
+        ) : !data ? (
+          <p className="text-[11px] text-fg-muted">{t("changes.loading")}</p>
+        ) : !data.available ? (
+          <p className="text-[11px] text-fg-muted">{t("changes.unavailable")}</p>
+        ) : files.length === 0 ? (
+          <p className="text-[11px] text-fg-muted">{t(`changes.empty.${range}`)}</p>
+        ) : mode === "overview" ? (
+          <>
+            <ul data-testid="lane-changes-overview" className="space-y-0.5">
+              {files.map((f) => (
+                <Row key={f.path} f={f} />
+              ))}
+            </ul>
+            {stagedCount > 0 && (
+              <div
+                data-testid="lane-changes-commit"
+                className="mt-2 flex items-center gap-1.5 border-t border-border-light pt-2"
+              >
+                <input
+                  value={message}
+                  onChange={(e) => setMessage(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter" && message.trim() && !busy) void commitStaged();
+                  }}
+                  placeholder={t("changes.commitPlaceholder")}
+                  aria-label={t("changes.commitPlaceholder")}
+                  className="min-w-0 flex-1 rounded border border-border-light bg-surface-0 px-2 py-0.5 text-[11px] text-fg-primary placeholder:text-fg-muted focus:border-accent focus:outline-none"
+                />
+                <button
+                  type="button"
+                  disabled={busy || !message.trim()}
+                  onClick={() => void commitStaged()}
+                  className="shrink-0 rounded border border-border-light px-1.5 py-0.5 text-[11px] text-fg-secondary hover:bg-surface-2 hover:text-fg-primary disabled:cursor-not-allowed disabled:opacity-40"
+                >
+                  {t("changes.commitStaged", { count: stagedCount })}
+                </button>
+              </div>
+            )}
+          </>
+        ) : mode === "file" ? (
+          current || (whole && text) ? (
+            <div className="flex min-h-0 flex-1 flex-col">
+              <div className="mb-1 flex items-baseline gap-1.5">
+                <FileText className="h-3 w-3 shrink-0 text-fg-muted" />
+                <span className="min-w-0 flex-1 truncate font-mono text-[11px] text-fg-primary">
+                  {openFile}
+                </span>
+                {current && (
+                  <Delta added={current.added} deleted={current.deleted} binary={current.binary} />
+                )}
+              </div>
+              {whole ? (
+                text ? (
+                  <LaneFileView
+                    path={text.path}
+                    lines={text.lines}
+                    truncated={text.truncated}
+                    fill
+                  />
+                ) : (
+                  <p className="text-[11px] text-fg-muted">{t("changes.loading")}</p>
+                )
+              ) : current ? (
+                <LaneDiffView file={current} layout={layout} fill />
+              ) : null}
+            </div>
+          ) : (
+            <p className="text-[11px] text-fg-muted">{t("changes.fileGone")}</p>
+          )
+        ) : (
+          <div data-testid="lane-changes-review" className="space-y-3">
+            {files.map((f) => {
+              const shut = collapsed.has(f.path);
+              return (
+                <div key={f.path} className="rounded border border-border-light">
+                  {/* The whole header folds the file; only the PATH opens it.
+                      A header that opened the file on any click made folding a
+                      target-practice exercise against one chevron. */}
+                  <div
+                    role="button"
+                    tabIndex={0}
+                    onClick={() => toggleCollapsed(f.path)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter" || e.key === " ") {
+                        e.preventDefault();
+                        toggleCollapsed(f.path);
+                      }
+                    }}
+                    aria-expanded={!shut}
+                    aria-label={
+                      shut
+                        ? t("changes.expandFile", { path: f.path })
+                        : t("changes.collapseFile", { path: f.path })
+                    }
+                    className={`flex cursor-pointer items-baseline gap-1.5 bg-surface-1 px-2 py-1 hover:bg-surface-2 ${
+                      shut ? "" : "border-b border-border-light"
+                    }`}
+                  >
+                    <ChevronRight
+                      className={`h-3 w-3 shrink-0 self-center text-fg-muted transition-transform ${
+                        shut ? "" : "rotate-90"
+                      }`}
+                    />
+                    <span
+                      className={`shrink-0 font-mono text-[11px] font-semibold ${statusClass(f.status, f.untracked)}`}
+                    >
+                      {f.untracked ? "A" : f.status.trim()[0] || "M"}
+                    </span>
+                    <button
+                      type="button"
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        show(f.path);
+                      }}
+                      className="min-w-0 flex-1 truncate text-left font-mono text-[11px] text-fg-primary hover:underline"
+                      title={t("changes.openFile", { path: f.path })}
+                    >
+                      {f.path}
+                    </button>
+                    <Delta added={f.added} deleted={f.deleted} binary={f.binary} />
+                  </div>
+                  {!shut && <LaneDiffView file={f} layout={layout} />}
+                </div>
+              );
+            })}
+          </div>
+        )}
+
+        {data?.available && data.truncated && mode !== "history" && mode !== "browse" && (
+          <p className="mt-2 text-[10px] text-status-warning">{t("changes.truncated")}</p>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default LaneChangesPanel;

client/src/components/lanes/LaneDiffView.tsx

@@ -0,0 +1,317 @@
+/**
+ * @file The diff renderer behind the Changes panel (issue #35): one file's
+ * hunks as a VS Code-style diff — unified or side-by-side, syntax-highlighted,
+ * with the changed span inside a modified line picked out.
+ *
+ * Three deliberate choices:
+ *   - Highlighting reuses `lib/highlight.ts`, the tokenizer the conversation
+ *     view already ships. No new dependency for a panel that renders a few
+ *     hundred lines.
+ *   - The intra-line diff is a common prefix/suffix trim, not a real LCS. It is
+ *     right for the case that matters (one edited span on a line), degrades to
+ *     "the whole line changed" otherwise, and costs nothing.
+ *   - Line pairing for split view happens here, on the rows the server already
+ *     numbered. The server stays the single source of what changed; this file
+ *     only decides how it looks.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { useCallback, useRef } from "react";
+import { useTranslation } from "react-i18next";
+import { canonicalLang, highlight, tokenClass } from "../../lib/highlight";
+import type { LaneChangeFile, LaneDiffHunk, LaneDiffLine } from "../../lib/types";
+
+export type DiffLayout = "unified" | "split";
+
+/**
+ * How tall a diff box may be. `fill` (the single-file view) takes the height
+ * its parent gives it; otherwise — the review list, which stacks many files —
+ * each file is capped so its own horizontal scrollbar stays on screen.
+ */
+function boxHeight(fill: boolean) {
+  return fill ? "min-h-0 flex-1" : "max-h-[60vh]";
+}
+
+/** Language tag for a path, for the tokenizer. Unknown ones render plain. */
+function langFor(filePath: string) {
+  const ext = filePath.split(".").pop() || "";
+  return canonicalLang(ext === filePath ? "plain" : ext);
+}
+
+/** Tokenized line text. `emph` marks the span that actually changed. */
+function Code({ text, lang, emph }: { text: string; lang: string; emph?: [number, number] }) {
+  if (emph) {
+    const [from, to] = emph;
+    return (
+      <>
+        <Code text={text.slice(0, from)} lang={lang} />
+        <span className="rounded-sm bg-white/15">
+          <Code text={text.slice(from, to)} lang={lang} />
+        </span>
+        <Code text={text.slice(to)} lang={lang} />
+      </>
+    );
+  }
+  return (
+    <>
+      {highlight(text, lang).map((tok, i) => (
+        <span key={i} className={tokenClass(tok.type)}>
+          {tok.text}
+        </span>
+      ))}
+    </>
+  );
+}
+
+/**
+ * The changed span of a del/add pair, as `[start, end]` offsets into each
+ * side, or null when the lines share nothing worth pointing at.
+ */
+function emphasis(
+  del: string,
+  add: string
+): { del: [number, number]; add: [number, number] } | null {
+  if (del === add) return null;
+  let start = 0;
+  const max = Math.min(del.length, add.length);
+  while (start < max && del[start] === add[start]) start += 1;
+  let end = 0;
+  while (end < max - start && del[del.length - 1 - end] === add[add.length - 1 - end]) end += 1;
+  // Nothing in common at either edge: the whole line is the change, and
+  // highlighting all of it adds noise on top of the row tint.
+  if (start === 0 && end === 0) return null;
+  return {
+    del: [start, del.length - end],
+    add: [start, add.length - end],
+  };
+}
+
+/** Pair each run of removed lines with the run of added lines following it. */
+function pairs(
+  lines: LaneDiffLine[]
+): Array<{ left: LaneDiffLine | null; right: LaneDiffLine | null }> {
+  const out: Array<{ left: LaneDiffLine | null; right: LaneDiffLine | null }> = [];
+  for (let i = 0; i < lines.length; ) {
+    const line = lines[i]!;
+    if (line.type === "ctx") {
+      out.push({ left: line, right: line });
+      i += 1;
+      continue;
+    }
+    const dels: LaneDiffLine[] = [];
+    const adds: LaneDiffLine[] = [];
+    while (i < lines.length && lines[i]!.type === "del") dels.push(lines[i++]!);
+    while (i < lines.length && lines[i]!.type === "add") adds.push(lines[i++]!);
+    for (let k = 0; k < Math.max(dels.length, adds.length); k += 1) {
+      out.push({ left: dels[k] ?? null, right: adds[k] ?? null });
+    }
+  }
+  return out;
+}
+
+function Gutter({ n }: { n: number | null }) {
+  return (
+    <span className="w-10 shrink-0 select-none px-1 text-right text-fg-muted/60">{n ?? ""}</span>
+  );
+}
+
+/** A diff row. `w-max min-w-full` so the tint still spans a scrolled-open row. */
+function Row({ tint, children }: { tint: string; children: React.ReactNode }) {
+  return <div className={`flex w-max min-w-full ${tint}`}>{children}</div>;
+}
+
+function rowTint(type: LaneDiffLine["type"] | null) {
+  if (type === "add") return "bg-status-success/10";
+  if (type === "del") return "bg-status-danger/10";
+  return "";
+}
+
+function HunkHeader({ hunk }: { hunk: LaneDiffHunk }) {
+  const at = hunk.header.split("@@")[1];
+  return (
+    <div className="bg-surface-2 px-2 py-0.5 text-[10px] text-fg-muted">
+      {at ? `@@${at}@@` : hunk.header}
+      {hunk.context ? ` ${hunk.context}` : ""}
+    </div>
+  );
+}
+
+function UnifiedHunk({ hunk, lang }: { hunk: LaneDiffHunk; lang: string }) {
+  const emph = new Map<number, [number, number]>();
+  for (const { left, right } of pairs(hunk.lines)) {
+    if (!left || !right || left.type !== "del" || right.type !== "add") continue;
+    const e = emphasis(left.text, right.text);
+    if (!e) continue;
+    emph.set(hunk.lines.indexOf(left), e.del);
+    emph.set(hunk.lines.indexOf(right), e.add);
+  }
+  return (
+    <div>
+      <HunkHeader hunk={hunk} />
+      {hunk.lines.map((line, i) => (
+        <Row key={i} tint={rowTint(line.type)}>
+          <Gutter n={line.oldLine} />
+          <Gutter n={line.newLine} />
+          <span className="whitespace-pre px-2">
+            <span className="select-none text-fg-muted">
+              {line.type === "add" ? "+" : line.type === "del" ? "-" : " "}
+            </span>
+            <Code text={line.text} lang={lang} emph={emph.get(i)} />
+          </span>
+        </Row>
+      ))}
+    </div>
+  );
+}
+
+/** One side of the split view: a hunk header, then that side's rows. */
+function SplitColumn({
+  hunks,
+  lang,
+  side,
+}: {
+  hunks: LaneDiffHunk[];
+  lang: string;
+  side: "left" | "right";
+}) {
+  return (
+    <>
+      {hunks.map((hunk, h) => (
+        <div key={`${hunk.header}:${h}`}>
+          <HunkHeader hunk={hunk} />
+          {pairs(hunk.lines).map(({ left, right }, i) => {
+            const e =
+              left && right && left.type === "del" && right.type === "add"
+                ? emphasis(left.text, right.text)
+                : null;
+            const line = side === "left" ? left : right;
+            return (
+              <Row key={i} tint={rowTint(line?.type ?? null)}>
+                <Gutter n={(side === "left" ? line?.oldLine : line?.newLine) ?? null} />
+                <span className="whitespace-pre px-1">
+                  {line ? (
+                    <Code text={line.text} lang={lang} emph={side === "left" ? e?.del : e?.add} />
+                  ) : null}
+                </span>
+              </Row>
+            );
+          })}
+        </div>
+      ))}
+    </>
+  );
+}
+
+/** Both sides, each scrolling horizontally on its own but kept in step. */
+function SplitView({ hunks, lang, fill }: { hunks: LaneDiffHunk[]; lang: string; fill: boolean }) {
+  const left = useRef<HTMLDivElement>(null);
+  const right = useRef<HTMLDivElement>(null);
+
+  // Mirroring fires the other pane's own scroll handler, which mirrors back —
+  // the equality check is what ends that, so no re-entry flag is needed.
+  const sync = useCallback((from: "left" | "right") => {
+    const src = from === "left" ? left.current : right.current;
+    const dst = from === "left" ? right.current : left.current;
+    if (!src || !dst || dst.scrollLeft === src.scrollLeft) return;
+    dst.scrollLeft = src.scrollLeft;
+  }, []);
+
+  return (
+    <div className={`flex ${boxHeight(fill)}`}>
+      <div
+        ref={left}
+        data-testid="lane-diff-split-left"
+        onScroll={() => sync("left")}
+        className="w-1/2 min-w-0 overflow-auto"
+      >
+        <SplitColumn hunks={hunks} lang={lang} side="left" />
+      </div>
+      <div
+        ref={right}
+        data-testid="lane-diff-split-right"
+        onScroll={() => sync("right")}
+        className="w-1/2 min-w-0 overflow-auto border-l border-border-light"
+      >
+        <SplitColumn hunks={hunks} lang={lang} side="right" />
+      </div>
+    </div>
+  );
+}
+
+/** One file's diff, in the chosen layout. */
+export function LaneDiffView({
+  file,
+  layout,
+  fill = false,
+}: {
+  file: LaneChangeFile;
+  layout: DiffLayout;
+  /** Take the parent's height (single-file view) instead of the 60vh cap. */
+  fill?: boolean;
+}) {
+  const { t } = useTranslation(["lanes"]);
+  const lang = langFor(file.path);
+
+  if (file.binary)
+    return <p className="px-2 py-1 text-[10px] text-fg-muted">{t("changes.binary")}</p>;
+  if (!file.hunks || file.hunks.length === 0)
+    return <p className="px-2 py-1 text-[10px] text-fg-muted">{t("changes.noHunks")}</p>;
+
+  return (
+    <div
+      data-testid="lane-diff-view"
+      data-layout={layout}
+      className={`flex flex-col font-mono text-[11px] leading-[1.45] ${
+        layout === "split" ? boxHeight(fill) : `overflow-auto ${boxHeight(fill)}`
+      }`}
+    >
+      {layout === "split" ? (
+        <SplitView hunks={file.hunks} lang={lang} fill={fill} />
+      ) : (
+        file.hunks.map((hunk, i) => (
+          <UnifiedHunk key={`${hunk.header}:${i}`} hunk={hunk} lang={lang} />
+        ))
+      )}
+      {file.truncated && (
+        <p className="px-2 py-1 text-[10px] text-status-warning">{t("changes.fileTruncated")}</p>
+      )}
+    </div>
+  );
+}
+
+/** A whole file's text (no diff), for the viewer's "read the file" mode. */
+export function LaneFileView({
+  path,
+  lines,
+  truncated,
+  fill = false,
+}: {
+  path: string;
+  lines: string[];
+  truncated?: boolean;
+  /** Take the parent's height instead of the 60vh cap. */
+  fill?: boolean;
+}) {
+  const { t } = useTranslation(["lanes"]);
+  const lang = langFor(path);
+  return (
+    <div
+      data-testid="lane-file-view"
+      className={`overflow-auto font-mono text-[11px] leading-[1.45] ${boxHeight(fill)}`}
+    >
+      {lines.map((text, i) => (
+        <Row key={i} tint="">
+          <Gutter n={i + 1} />
+          <span className="whitespace-pre px-2">
+            <Code text={text} lang={lang} />
+          </span>
+        </Row>
+      ))}
+      {truncated && (
+        <p className="px-2 py-1 text-[10px] text-status-warning">{t("changes.fileTruncated")}</p>
+      )}
+    </div>
+  );
+}
+
+export default LaneDiffView;

client/src/components/lanes/LaneGitBar.tsx

@@ -0,0 +1,352 @@
+/**
+ * @file The lane's git action row: ahead/behind against the upstream, and the
+ * writes `POST /api/lanes/:id/git/:action` offers that are not per-file —
+ * fetch, pull, push, commit (everything, or only what the Changes panel has
+ * staged), switch branch, and create/delete a branch. Per-file staging and
+ * discard live in the Changes panel, beside the file they act on.
+ *
+ * It renders beside the read-only git line in LaneCard rather than inside the
+ * ⋯ menu: that menu holds the rare and dangerous (`reset worktree`), and these
+ * are the opposite — the ordinary moves a lane needs several times an hour.
+ * Nothing here decides what an action may do; the server does (pull is always
+ * --ff-only, switch refuses a dirty tree), and this only reports what it said.
+ * Failures print git's own text, because "! [rejected] non-fast-forward" tells
+ * the user more than any sentence this file could write.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+  ArrowDown,
+  ArrowUp,
+  Check,
+  GitBranch,
+  Plus,
+  RefreshCw,
+  Trash2,
+  Upload,
+  X,
+} from "lucide-react";
+import { api } from "../../lib/api";
+import type { LaneGitFacts, LaneWorktree } from "../../lib/types";
+
+type Action = "fetch" | "pull" | "push" | "commit" | "switch" | "branch-create" | "branch-delete";
+
+function Btn({
+  label,
+  icon,
+  busy,
+  disabled,
+  title,
+  onClick,
+}: {
+  label: string;
+  icon?: React.ReactNode;
+  busy?: boolean;
+  disabled?: boolean;
+  title?: string;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled || busy}
+      title={title}
+      className="flex items-center gap-1 rounded border border-border-light px-1.5 py-0.5 text-[11px] text-fg-secondary transition-colors hover:bg-surface-2 hover:text-fg-primary disabled:cursor-not-allowed disabled:opacity-40"
+    >
+      {icon}
+      {label}
+    </button>
+  );
+}
+
+export function LaneGitBar({
+  laneId,
+  git,
+  onChanged,
+  onNewLane,
+}: {
+  laneId: number;
+  git: LaneGitFacts;
+  /** Called after any action that could have moved the working copy. */
+  onChanged: () => void;
+  /** Open the Add-lane flow for a sibling worktree of this repo, optionally on
+   *  a branch this bar just created. Omitted where no such flow is reachable. */
+  onNewLane?: (branch?: string) => void;
+}) {
+  const { t } = useTranslation(["lanes"]);
+  const [busy, setBusy] = useState<Action | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [committing, setCommitting] = useState(false);
+  const [message, setMessage] = useState("");
+  const [switching, setSwitching] = useState(false);
+  const [branches, setBranches] = useState<string[] | null>(null);
+  const [worktrees, setWorktrees] = useState<LaneWorktree[]>([]);
+  const [picked, setPicked] = useState("");
+  const [newBranch, setNewBranch] = useState("");
+
+  if (!git.available) return null;
+  const dirty = git.dirty + git.untracked;
+
+  const run = async (
+    action: Action,
+    body?: { message?: string; only?: "staged"; branch?: string }
+  ) => {
+    setBusy(action);
+    setError(null);
+    try {
+      await api.lanes.gitAction(laneId, action, body || {});
+      setCommitting(false);
+      setMessage("");
+      // The branch list this bar is showing is stale the moment a branch is
+      // created, deleted or switched to, so it is re-read rather than patched.
+      if (action === "switch") setSwitching(false);
+      else if (action.startsWith("branch-")) {
+        setNewBranch("");
+        setPicked("");
+        setBranches(null);
+        await refreshBranches();
+      }
+      onChanged();
+    } catch (err) {
+      // The server appends git's own stderr to the message, so this is the
+      // rejection text verbatim — hence the <pre> below rather than a line.
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const refreshBranches = async () => {
+    try {
+      const r = await api.lanes.gitBranches(laneId);
+      setBranches(r.branches);
+      setWorktrees(r.worktrees || []);
+    } catch {
+      setBranches([]);
+    }
+  };
+
+  const openSwitch = async () => {
+    setSwitching((v) => !v);
+    setError(null);
+    if (branches) return;
+    await refreshBranches();
+  };
+
+  const heldBy = new Map(
+    worktrees.filter((w) => w.branch).map((w) => [w.branch as string, w.path])
+  );
+
+  return (
+    <div data-testid="lane-git-bar" className="mb-2 space-y-1">
+      <div className="flex flex-wrap items-center gap-1.5">
+        {/* Ahead/behind first: it is the fact that decides which of the
+            buttons beside it the user actually wants. */}
+        {git.upstream ? (
+          <span
+            data-testid="lane-git-tracking"
+            title={git.upstream}
+            className="flex items-center gap-1 font-mono text-[11px] text-fg-muted"
+          >
+            {(git.ahead ?? 0) > 0 && (
+              <span className="flex items-center text-status-warning">
+                <ArrowUp className="h-3 w-3" />
+                {git.ahead}
+              </span>
+            )}
+            {(git.behind ?? 0) > 0 && (
+              <span className="flex items-center text-accent">
+                <ArrowDown className="h-3 w-3" />
+                {git.behind}
+              </span>
+            )}
+            {!git.ahead && !git.behind && <span>{t("gitBar.inSync")}</span>}
+          </span>
+        ) : (
+          git.hasRemote && (
+            <span className="font-mono text-[11px] text-fg-muted">{t("gitBar.noUpstream")}</span>
+          )
+        )}
+
+        <Btn
+          label={t("gitBar.fetch")}
+          icon={<RefreshCw className="h-3 w-3" />}
+          busy={busy === "fetch"}
+          disabled={!git.hasRemote || !!busy}
+          title={t("gitBar.fetchHint")}
+          onClick={() => run("fetch")}
+        />
+        <Btn
+          label={t("gitBar.pull")}
+          icon={<ArrowDown className="h-3 w-3" />}
+          busy={busy === "pull"}
+          disabled={!git.hasRemote || !!busy}
+          title={t("gitBar.pullHint")}
+          onClick={() => run("pull")}
+        />
+        <Btn
+          label={t("gitBar.push")}
+          icon={<Upload className="h-3 w-3" />}
+          busy={busy === "push"}
+          disabled={!git.hasRemote || !!busy}
+          title={t("gitBar.pushHint")}
+          onClick={() => run("push")}
+        />
+        <Btn
+          label={t("gitBar.commit")}
+          icon={<Check className="h-3 w-3" />}
+          disabled={dirty === 0 || !!busy}
+          title={dirty === 0 ? t("gitBar.commitNothing") : t("gitBar.commitHint")}
+          onClick={() => {
+            setCommitting((v) => !v);
+            setError(null);
+          }}
+        />
+        <Btn
+          label={t("gitBar.switch")}
+          icon={<GitBranch className="h-3 w-3" />}
+          disabled={!!busy}
+          // A dirty tree is refused server-side; saying so before the click
+          // beats a red box after it.
+          title={dirty > 0 ? t("gitBar.switchDirty") : t("gitBar.switchHint")}
+          onClick={openSwitch}
+        />
+      </div>
+
+      {committing && (
+        <div className="flex items-center gap-1.5">
+          <input
+            autoFocus
+            value={message}
+            onChange={(e) => setMessage(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter" && message.trim()) void run("commit", { message });
+              if (e.key === "Escape") setCommitting(false);
+            }}
+            placeholder={t("gitBar.commitPlaceholder")}
+            aria-label={t("gitBar.commitPlaceholder")}
+            className="min-w-0 flex-1 rounded border border-border-light bg-surface-0 px-2 py-0.5 text-[11px] text-fg-primary placeholder:text-fg-muted focus:border-accent focus:outline-none"
+          />
+          <Btn
+            label={t("gitBar.commitAll", { count: dirty })}
+            busy={busy === "commit"}
+            disabled={!message.trim()}
+            onClick={() => void run("commit", { message })}
+          />
+          {/* The Changes panel's per-file staging only means something if a
+              commit can take the index as it stands. The server answers
+              ENOCHANGES when nothing is staged, and that text lands below. */}
+          <Btn
+            label={t("gitBar.commitStaged")}
+            title={t("gitBar.commitStagedHint")}
+            busy={busy === "commit"}
+            disabled={!message.trim()}
+            onClick={() => void run("commit", { message, only: "staged" })}
+          />
+          <button
+            type="button"
+            aria-label={t("gitBar.cancel")}
+            onClick={() => setCommitting(false)}
+            className="text-fg-muted hover:text-fg-primary"
+          >
+            <X className="h-3.5 w-3.5" />
+          </button>
+        </div>
+      )}
+
+      {switching && (
+        <div className="flex items-center gap-1.5">
+          <select
+            aria-label={t("gitBar.switchLabel")}
+            value={picked}
+            disabled={!!busy}
+            onChange={(e) => setPicked(e.target.value)}
+            className="min-w-0 flex-1 rounded border border-border-light bg-surface-0 px-2 py-0.5 font-mono text-[11px] text-fg-primary focus:border-accent focus:outline-none disabled:opacity-40"
+          >
+            <option value="">{t("gitBar.switchLabel")}</option>
+            {(branches || []).map((b) => {
+              const held = heldBy.get(b);
+              return (
+                <option key={b} value={b}>
+                  {b}
+                  {b === git.branch ? ` — ${t("gitBar.switchCurrent")}` : held ? ` — ${held}` : ""}
+                </option>
+              );
+            })}
+          </select>
+          <Btn
+            label={t("gitBar.switchApply")}
+            busy={busy === "switch"}
+            // A branch git already has checked out somewhere else cannot be
+            // switched to — git allows one worktree per branch.
+            disabled={!picked || picked === git.branch || !!heldBy.get(picked) || dirty > 0}
+            title={dirty > 0 ? t("gitBar.switchDirty") : t("gitBar.switchHint")}
+            onClick={() => void run("switch", { branch: picked })}
+          />
+          {onNewLane && (
+            <Btn
+              label={t("gitBar.newLane")}
+              title={t("gitBar.newLaneHint")}
+              disabled={!picked}
+              // The sibling lane is created through the normal Add-lane flow,
+              // prefilled — one provisioning path, not a second one here.
+              onClick={() => onNewLane(picked)}
+            />
+          )}
+          <Btn
+            label={t("gitBar.branchDelete")}
+            icon={<Trash2 className="h-3 w-3" />}
+            busy={busy === "branch-delete"}
+            disabled={!picked || picked === git.branch || !!heldBy.get(picked)}
+            title={t("gitBar.branchDeleteHint")}
+            onClick={() => void run("branch-delete", { branch: picked })}
+          />
+          {dirty > 0 && (
+            <span className="text-[10px] text-status-warning">{t("gitBar.switchDirty")}</span>
+          )}
+        </div>
+      )}
+
+      {switching && (
+        <div className="flex items-center gap-1.5">
+          <input
+            value={newBranch}
+            onChange={(e) => setNewBranch(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter" && newBranch.trim())
+                void run("branch-create", { branch: newBranch.trim() });
+            }}
+            placeholder={t("gitBar.branchNewPlaceholder")}
+            aria-label={t("gitBar.branchNewPlaceholder")}
+            className="min-w-0 flex-1 rounded border border-border-light bg-surface-0 px-2 py-0.5 font-mono text-[11px] text-fg-primary placeholder:text-fg-muted focus:border-accent focus:outline-none"
+          />
+          <Btn
+            label={t("gitBar.branchCreate")}
+            icon={<Plus className="h-3 w-3" />}
+            busy={busy === "branch-create"}
+            disabled={!newBranch.trim()}
+            // Creating does not switch: the point is usually a sibling lane,
+            // and moving this pane's HEAD under a working agent is not.
+            title={t("gitBar.branchCreateHint")}
+            onClick={() => void run("branch-create", { branch: newBranch.trim() })}
+          />
+        </div>
+      )}
+
+      {error && (
+        <pre
+          role="alert"
+          data-testid="lane-git-bar-error"
+          className="max-h-24 overflow-auto whitespace-pre-wrap rounded border border-status-danger/40 bg-status-danger/10 px-2 py-1 text-[10px] text-status-danger"
+        >
+          {error}
+        </pre>
+      )}
+    </div>
+  );
+}
+
+export default LaneGitBar;

client/src/components/lanes/__tests__/AddLaneModal.test.tsx

@@ -109,18 +109,6 @@ async function fillWorktreeForm(
 
 beforeEach(() => {
   vi.mocked(api.lanes.branches).mockReset();
-  vi.mocked(api.lanes.pipelines)
-    .mockReset()
-    .mockResolvedValue({
-      pipelines: [
-        { id: "default", name: "Default feature pipeline", nodes: new Array(8).fill({ id: "n" }) },
-        {
-          id: "ship-feature",
-          name: "Ship feature (lane pipeline)",
-          nodes: new Array(16).fill({ id: "n" }),
-        },
-      ],
-    });
   vi.mocked(api.lanes.worktree).mockReset();
   vi.mocked(api.lanes.ensure).mockReset();
   vi.mocked(api.lanes.browse).mockReset();
@@ -181,8 +169,101 @@ function savedRouter(over: Record<string, unknown> = {}) {
   };
 }
 
+describe("AddLaneModal — picking an existing branch (issue #34)", () => {
+  const withWorktrees = {
+    branches: ["main", "feat/other", "feat/held"],
+    current: "main",
+    worktrees: [
+      { path: "/Users/tester/projects/repo", branch: "main" },
+      { path: "/lanes/repo__held", branch: "feat/held" },
+    ],
+  };
+
+  it("lists the repo's existing worktrees once the path resolves", async () => {
+    vi.mocked(api.lanes.branches).mockResolvedValue(withWorktrees);
+    renderModal();
+    const user = userEvent.setup();
+
+    const repoField = screen.getByLabelText("Source repository");
+    await focusField(user, repoField);
+    await user.type(repoField, "/Users/tester/projects/repo");
+
+    const panel = await screen.findByTestId("add-lane-worktrees");
+    expect(panel).toHaveTextContent("/lanes/repo__held");
+    expect(panel).toHaveTextContent("feat/held");
+  });
+
+  it("checks an existing branch out, sending no base", async () => {
+    vi.mocked(api.lanes.branches).mockResolvedValue(withWorktrees);
+    vi.mocked(api.lanes.worktree).mockResolvedValue({ lane: laneFixture({ id: 9 }) });
+    renderModal();
+    const user = userEvent.setup();
+
+    const repoField = screen.getByLabelText("Source repository");
+    await focusField(user, repoField);
+    await user.type(repoField, "/Users/tester/projects/repo");
+    await screen.findByLabelText("Branch to fork from");
+    await user.type(screen.getByLabelText("Title"), "Reuse a branch");
+
+    await user.click(screen.getByRole("button", { name: "Existing branch" }));
+    const select = await screen.findByLabelText("Branch to check out");
+    await user.selectOptions(select, "feat/other");
+    await user.click(screen.getByRole("button", { name: "Add lane" }));
+
+    await waitFor(() =>
+      expect(api.lanes.worktree).toHaveBeenCalledWith(
+        expect.objectContaining({ branch: "feat/other", base: undefined })
+      )
+    );
+  });
+
+  it("greys out a branch another worktree already holds", async () => {
+    vi.mocked(api.lanes.branches).mockResolvedValue(withWorktrees);
+    renderModal();
+    const user = userEvent.setup();
+
+    const repoField = screen.getByLabelText("Source repository");
+    await focusField(user, repoField);
+    await user.type(repoField, "/Users/tester/projects/repo");
+    await screen.findByLabelText("Branch to fork from");
+    await user.click(screen.getByRole("button", { name: "Existing branch" }));
+
+    const held = await screen.findByRole("option", { name: /feat\/held/ });
+    expect(held).toBeDisabled();
+    expect(held).toHaveTextContent("/lanes/repo__held");
+    expect(screen.getByRole("option", { name: "feat/other" })).toBeEnabled();
+  });
+
+  it("lets the server name a new branch when the field is left empty", async () => {
+    vi.mocked(api.lanes.branches).mockResolvedValue(withWorktrees);
+    vi.mocked(api.lanes.worktree).mockResolvedValue({ lane: laneFixture({ id: 9 }) });
+    renderModal();
+    const user = userEvent.setup();
+
+    const repoField = screen.getByLabelText("Source repository");
+    await focusField(user, repoField);
+    await user.type(repoField, "/Users/tester/projects/repo");
+    await screen.findByLabelText("Branch to fork from");
+    await user.type(screen.getByLabelText("Title"), "Auto named");
+    // The placeholder previews the name the server will pick.
+    expect(screen.getByLabelText("New branch name")).toHaveAttribute(
+      "placeholder",
+      "feat/auto-named"
+    );
+
+    await user.click(screen.getByRole("button", { name: "Add lane" }));
+    await waitFor(() =>
+      expect(api.lanes.worktree).toHaveBeenCalledWith(
+        expect.objectContaining({ branch: undefined, base: "main" })
+      )
+    );
+  });
+});
+
 describe("AddLaneModal — worktree mode (default)", () => {
-  it("disables confirm until a repo, a title, a resolved branch list, and a new branch name are all present", () => {
+  // The branch NAME is no longer part of this list: an empty one means "let
+  // the server name it" (issue #34).
+  it("disables confirm until a repo, a title and a resolved branch list are all present", () => {
     renderModal();
     expect(screen.getByRole("button", { name: "Add lane" })).toBeDisabled();
   });
@@ -191,6 +272,7 @@ describe("AddLaneModal — worktree mode (default)", () => {
     vi.mocked(api.lanes.branches).mockResolvedValue({
       branches: ["main", "feat/other"],
       current: "main",
+      worktrees: [],
     });
     renderModal();
     const user = userEvent.setup();
@@ -223,7 +305,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("submits through the worktree provisioning endpoint, with the typed branch name", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockResolvedValue({ lane: laneFixture({ id: 9 }) });
     const onAdded = vi.fn();
     const onClose = vi.fn();
@@ -239,7 +325,6 @@ describe("AddLaneModal — worktree mode (default)", () => {
         title: "New feature",
         base: "main",
         branch: "feat/new-feature",
-        pipeline: "default",
         tool: "claude",
       });
     });
@@ -253,7 +338,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("shows a server error and leaves the modal open instead of closing silently", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockRejectedValue(new Error("EWORKTREEDIRCOLLISION"));
     const onClose = vi.fn();
     renderModal({ onClose });
@@ -272,7 +361,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("fires profileInit, agentsInstall, and mcpSync after a successful worktree call", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockResolvedValue({
       lane: { id: 42, title: "demo", cwd: "/lanes/demo", status: "provisioning" } as Lane,
     });
@@ -291,7 +384,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("still calls onAdded even when every setup call fails", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockResolvedValue({
       lane: { id: 43, title: "demo2", cwd: "/lanes/demo2", status: "provisioning" } as Lane,
     });
@@ -311,7 +408,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("keeps the summary up when a setup step FAILED, and closes on the button that replaces Add lane", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockResolvedValue({
       lane: { id: 44, title: "demo3", cwd: "/lanes/demo3", status: "provisioning" } as Lane,
     });
@@ -334,7 +435,11 @@ describe("AddLaneModal — worktree mode (default)", () => {
   });
 
   it("waits for the background worktree provisioning to finish before running setup, and skips setup if it fails", async () => {
-    vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["main"],
+      current: "main",
+      worktrees: [],
+    });
     vi.mocked(api.lanes.worktree).mockResolvedValue({
       lane: { id: 45, title: "demo4", cwd: "/lanes/demo4", status: "provisioning" } as Lane,
     });
@@ -397,7 +502,6 @@ describe("AddLaneModal — repo mode (adopt)", () => {
       expect(api.lanes.ensure).toHaveBeenCalledWith({
         cwd: "/Users/tester/projects/repo",
         title: "main repo",
-        pipeline: "default",
         tool: "claude",
       })
     );
@@ -591,50 +695,6 @@ describe("AddLaneModal — a router profile that disappeared", () => {
   });
 });
 
-describe("AddLaneModal — pipeline template", () => {
-  it("offers every template the server reports and sends the chosen one when adopting a repo", async () => {
-    // Creation is the ONLY point the UI can set a template, so a lane born on
-    // `default` renders 8 nodes for a 16-node workflow with no way back from
-    // any screen.
-    vi.mocked(api.lanes.ensure).mockResolvedValue({
-      lane: laneFixture({ status: "idle" }),
-      created: true,
-    });
-    renderModal();
-    const user = userEvent.setup();
-
-    await user.click(screen.getByRole("button", { name: "Repo" }));
-    const select = await screen.findByLabelText("Pipeline template");
-    await waitFor(() =>
-      expect(screen.getByRole("option", { name: /Ship feature/ })).toBeInTheDocument()
-    );
-    expect(
-      screen.getByRole("option", { name: /Default feature pipeline \(8\)/ })
-    ).toBeInTheDocument();
-
-    const repoField = screen.getByLabelText("Directory");
-    await focusField(user, repoField);
-    await user.type(repoField, "/Users/tester/projects/repo");
-    await user.selectOptions(select, "ship-feature");
-    await user.click(screen.getByRole("button", { name: "Add lane" }));
-
-    await waitFor(() =>
-      expect(api.lanes.ensure).toHaveBeenCalledWith(
-        expect.objectContaining({ pipeline: "ship-feature" })
-      )
-    );
-  });
-
-  it("still renders a usable select, and still creates the lane, when the template list cannot be fetched", async () => {
-    vi.mocked(api.lanes.pipelines).mockRejectedValue(new Error("offline"));
-    renderModal();
-
-    const select = await screen.findByLabelText("Pipeline template");
-    await waitFor(() => expect(select).toHaveValue("default"));
-    expect(screen.getByRole("option", { name: "default" })).toBeInTheDocument();
-  });
-});
-
 describe("AddLaneModal — tool selection", () => {
   it("sends the picked tool when adopting a repo", async () => {
     vi.mocked(api.lanes.ensure).mockResolvedValue({
@@ -679,3 +739,41 @@ describe("AddLaneModal — tool selection", () => {
     );
   });
 });
+
+describe("AddLaneModal — working straight on main (no worktree)", () => {
+  beforeEach(() => {
+    vi.mocked(api.lanes.branches).mockResolvedValue({
+      branches: ["development", "main"],
+      current: "development",
+      worktrees: [],
+    });
+  });
+
+  it("jumps to Repo mode from the branch choice", async () => {
+    const user = userEvent.setup();
+    renderModal();
+    const repoField = screen.getByLabelText("Source repository");
+    await focusField(user, repoField);
+    await user.type(repoField, "/Users/tester/projects/repo");
+    await screen.findByTestId("add-lane-branch-section");
+
+    await user.click(screen.getByRole("button", { name: "Current branch" }));
+
+    // Repo mode adopts the directory as it stands — no branch section left to
+    // answer, because there is no fork to configure.
+    expect(screen.queryByTestId("add-lane-branch-section")).toBeNull();
+    expect(screen.getByRole("button", { name: "Repo" })).toHaveAttribute("aria-pressed", "true");
+  });
+
+  it("prefills the repo and branch it was opened with", async () => {
+    renderModal({
+      prefill: { sourceRepo: "/Users/tester/projects/repo", branch: "development" },
+    });
+    expect(await screen.findByTestId("add-lane-branch-section")).toBeInTheDocument();
+    expect(screen.getByLabelText("Source repository")).toHaveValue("/Users/tester/projects/repo");
+    expect(screen.getByRole("button", { name: "Existing branch" })).toHaveAttribute(
+      "aria-pressed",
+      "true"
+    );
+  });
+});

client/src/components/lanes/__tests__/LaneCard.test.tsx

@@ -216,6 +216,12 @@ describe("LaneCard git block", () => {
       { path: "client/src/lib/api.ts", status: "M ", added: 1, deleted: 0 },
       { path: "scratch.txt", status: "??", added: null, deleted: null },
     ],
+    // Tracking facts ride along on the same endpoint; a branch that has never
+    // been pushed reports nulls rather than zeros.
+    hasRemote: true,
+    upstream: null,
+    ahead: null,
+    behind: null,
   };
 
   it("renders the live branch, head, subject and uncommitted counts", async () => {

client/src/components/lanes/__tests__/LaneChangesPanel.test.tsx

@@ -0,0 +1,540 @@
+/**
+ * @file LaneChangesPanel.test.tsx
+ * @description Pins the Changes panel's five modes and its three ranges: the
+ * overview lists files and nothing else, clicking one opens that file's diff
+ * (and asks the server for THAT path), Review asks for every file's hunks at
+ * once, the range toggle changes which comparison is requested, History opens
+ * one commit, and Files quick-opens a whole file. Also pins the per-file git
+ * writes — including discard needing two clicks before the server hears
+ * `confirm` — and the degrade for a cwd git cannot read.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { LaneChangesPanel } from "../LaneChangesPanel";
+import { api } from "../../../lib/api";
+import type { LaneChanges } from "../../../lib/types";
+
+vi.mock("../../../lib/api", () => ({
+  api: {
+    lanes: {
+      changes: vi.fn(),
+      gitAction: vi.fn(),
+      gitLog: vi.fn(),
+      gitFile: vi.fn(),
+      gitLs: vi.fn(),
+      gitTree: vi.fn(),
+    },
+  },
+}));
+
+const HUNK = {
+  header: "@@ -1,2 +1,3 @@",
+  context: "",
+  oldStart: 1,
+  newStart: 1,
+  lines: [
+    { type: "ctx" as const, oldLine: 1, newLine: 1, text: "keep" },
+    { type: "del" as const, oldLine: 2, newLine: null, text: "old line" },
+    { type: "add" as const, oldLine: null, newLine: 2, text: "new line" },
+  ],
+};
+
+function changes(over: Partial<Extract<LaneChanges, { available: true }>> = {}): LaneChanges {
+  return {
+    available: true,
+    range: "work",
+    base: "development",
+    baseRef: "origin/development",
+    sha: null,
+    context: 3,
+    truncated: false,
+    files: [
+      {
+        path: "server/lib/git-ops.js",
+        status: " M",
+        untracked: false,
+        unstaged: true,
+        added: 12,
+        deleted: 3,
+        binary: false,
+      },
+      { path: "notes.txt", status: "??", untracked: true, added: 4, deleted: 0, binary: false },
+      {
+        path: "docs/API.md",
+        status: "M ",
+        untracked: false,
+        staged: true,
+        added: 2,
+        deleted: 1,
+        binary: false,
+      },
+    ],
+    ...over,
+  };
+}
+
+beforeEach(() => {
+  vi.mocked(api.lanes.changes).mockReset();
+  vi.mocked(api.lanes.changes).mockResolvedValue(changes());
+  vi.mocked(api.lanes.gitAction).mockReset();
+  vi.mocked(api.lanes.gitAction).mockResolvedValue({ action: "stage", ok: true, output: "" });
+  vi.mocked(api.lanes.gitLog).mockResolvedValue({
+    available: true,
+    commits: [
+      {
+        sha: "a".repeat(40),
+        short: "aaaaaaa",
+        subject: "feat: the commit",
+        author: "t",
+        date: "2026-09-22T01:00:00Z",
+        refs: ["HEAD -> feat/thing"],
+      },
+    ],
+  });
+  vi.mocked(api.lanes.gitLs).mockResolvedValue({
+    available: true,
+    paths: ["src/main.ts"],
+    truncated: false,
+    total: 1,
+  });
+  vi.mocked(api.lanes.gitTree).mockResolvedValue({
+    available: true,
+    path: "",
+    entries: [{ name: "src", path: "src", dir: true }],
+    truncated: false,
+  });
+  vi.mocked(api.lanes.gitFile).mockResolvedValue({
+    available: true,
+    path: "src/main.ts",
+    rev: "work",
+    binary: false,
+    truncated: false,
+    lines: ["const whole = 1;"],
+  });
+});
+
+describe("LaneChangesPanel", () => {
+  it("opens on the overview: a summary request, files listed, no diff bodies", async () => {
+    render(<LaneChangesPanel laneId={7} />);
+
+    expect(await screen.findByTestId("lane-changes-overview")).toBeInTheDocument();
+    expect(api.lanes.changes).toHaveBeenCalledWith(7, { range: "work" });
+    expect(screen.getByText("server/lib/git-ops.js")).toBeInTheDocument();
+    expect(screen.getByText("+12")).toBeInTheDocument();
+    expect(screen.queryByText(/new line/)).toBeNull();
+  });
+
+  it("opens one file's diff when its row is clicked, asking for that path only", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    vi.mocked(api.lanes.changes).mockResolvedValue(
+      changes({
+        files: [
+          {
+            path: "server/lib/git-ops.js",
+            status: " M",
+            untracked: false,
+            added: 12,
+            deleted: 3,
+            binary: false,
+            hunks: [HUNK],
+          },
+        ],
+      })
+    );
+    await user.click(screen.getByText("server/lib/git-ops.js"));
+
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "work",
+        path: "server/lib/git-ops.js",
+        context: 3,
+      })
+    );
+    // The highlighter splits a line into one span per token, so assert on the
+    // rendered text of the whole view rather than on a single node.
+    const view = await screen.findByTestId("lane-diff-view");
+    expect(view).toHaveTextContent("new line");
+    // Both gutters are rendered, so a reviewer can cite a line number.
+    expect(view).toHaveTextContent("keep");
+  });
+
+  it("asks for every file's hunks in review mode", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "Review" }));
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, { range: "work", full: true })
+    );
+    expect(await screen.findByTestId("lane-changes-review")).toBeInTheDocument();
+  });
+
+  it("switches the comparison when the range toggle is used", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "vs base" }));
+    await waitFor(() => expect(api.lanes.changes).toHaveBeenCalledWith(7, { range: "branch" }));
+  });
+
+  it("says so, quietly, when the lane's directory is not a git repo", async () => {
+    vi.mocked(api.lanes.changes).mockResolvedValue({
+      available: false,
+      range: "work",
+      files: [],
+    });
+    render(<LaneChangesPanel laneId={7} />);
+    expect(
+      await screen.findByText("This lane's directory is not a readable git repository.")
+    ).toBeInTheDocument();
+  });
+
+  it("stages one file and asks the server for that path alone", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    // Both rows offer it (one modified, one untracked); the first is the
+    // modified file the assertion below names.
+    const [stage] = screen.getAllByRole("button", { name: "Stage this file" });
+    await user.click(stage!);
+    expect(api.lanes.gitAction).toHaveBeenCalledWith(7, "stage", {
+      paths: ["server/lib/git-ops.js"],
+    });
+  });
+
+  it("needs two clicks to discard, and only the second one reaches the server", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    const [discard] = screen.getAllByRole("button", { name: "Discard this file's changes" });
+    await user.click(discard!);
+    expect(api.lanes.gitAction).not.toHaveBeenCalled();
+
+    await user.click(
+      screen.getByRole("button", { name: "Click again to discard — this cannot be undone" })
+    );
+    expect(api.lanes.gitAction).toHaveBeenCalledWith(7, "discard", {
+      paths: ["server/lib/git-ops.js"],
+      confirm: true,
+    });
+  });
+
+  it("opens a commit from history as a commit-range review", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "History" }));
+    await user.click(await screen.findByText("feat: the commit"));
+
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "commit",
+        sha: "a".repeat(40),
+        full: true,
+      })
+    );
+    expect(await screen.findByTestId("lane-changes-commit-chip")).toHaveTextContent("aaaaaaa");
+  });
+
+  it("expands a folder in place, keeping its siblings visible, instead of navigating into it", async () => {
+    const user = userEvent.setup();
+    vi.mocked(api.lanes.gitTree).mockImplementation(async (_id, path) =>
+      path === "src"
+        ? {
+            available: true,
+            path: "src",
+            entries: [{ name: "main.ts", path: "src/main.ts", dir: false }],
+            truncated: false,
+          }
+        : {
+            available: true,
+            path: "",
+            entries: [{ name: "src", path: "src", dir: true }],
+            truncated: false,
+          }
+    );
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "Files" }));
+    await user.click(await screen.findByText("src"));
+
+    expect(await screen.findByText("main.ts")).toBeInTheDocument();
+    // The root's "src" row is still there — expanding did not replace the list.
+    expect(screen.getByText("src")).toBeInTheDocument();
+  });
+
+  it("expands every folder at once, fetching whatever level wasn't cached yet", async () => {
+    const user = userEvent.setup();
+    vi.mocked(api.lanes.gitTree).mockImplementation(async (_id, path) => {
+      if (path === "src")
+        return {
+          available: true,
+          path: "src",
+          entries: [{ name: "main.ts", path: "src/main.ts", dir: false }],
+          truncated: false,
+        };
+      return {
+        available: true,
+        path: "",
+        entries: [{ name: "src", path: "src", dir: true }],
+        truncated: false,
+      };
+    });
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "Files" }));
+    await screen.findByText("src");
+    await user.click(screen.getByRole("button", { name: "Expand all folders" }));
+
+    expect(await screen.findByText("main.ts")).toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "Collapse all folders" }));
+    expect(screen.queryByText("main.ts")).not.toBeInTheDocument();
+    expect(screen.getByText("src")).toBeInTheDocument();
+  });
+
+  it("quick-opens a tracked file as its whole content, not a diff", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    await user.click(screen.getByRole("button", { name: "Files" }));
+    await user.type(await screen.findByLabelText("Find a file by path…"), "main");
+    await user.click(await screen.findByText("src/main.ts"));
+
+    await waitFor(() => expect(api.lanes.gitFile).toHaveBeenCalledWith(7, "src/main.ts", "work"));
+    expect(await screen.findByTestId("lane-file-view")).toHaveTextContent("const whole = 1;");
+  });
+
+  it("switches the diff to side-by-side", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    vi.mocked(api.lanes.changes).mockResolvedValue(
+      changes({
+        files: [
+          {
+            path: "server/lib/git-ops.js",
+            status: " M",
+            untracked: false,
+            added: 12,
+            deleted: 3,
+            binary: false,
+            hunks: [HUNK],
+          },
+        ],
+      })
+    );
+    await user.click(screen.getByText("server/lib/git-ops.js"));
+    expect(await screen.findByTestId("lane-diff-view")).toHaveAttribute("data-layout", "unified");
+
+    await user.click(screen.getByRole("button", { name: "Side-by-side" }));
+    expect(screen.getByTestId("lane-diff-view")).toHaveAttribute("data-layout", "split");
+  });
+
+  it("expands and then collapses the context again", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    await user.click(screen.getByText("server/lib/git-ops.js"));
+    await screen.findByRole("button", { name: "Show more surrounding lines" });
+
+    // Collapse is dead at the tightest step, and live once expanded — an
+    // expanded diff that cannot be collapsed sends the reader back out of the
+    // file to get the tight view.
+    expect(screen.getByRole("button", { name: "Show fewer surrounding lines" })).toBeDisabled();
+    await user.click(screen.getByRole("button", { name: "Show more surrounding lines" }));
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "work",
+        path: "server/lib/git-ops.js",
+        context: 12,
+      })
+    );
+
+    await user.click(screen.getByRole("button", { name: "Show fewer surrounding lines" }));
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "work",
+        path: "server/lib/git-ops.js",
+        context: 3,
+      })
+    );
+  });
+
+  it("asks for more context when the diff is expanded", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    await user.click(screen.getByText("server/lib/git-ops.js"));
+    await screen.findByText(/server\/lib\/git-ops\.js/);
+
+    await user.click(screen.getByRole("button", { name: "Show more surrounding lines" }));
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "work",
+        path: "server/lib/git-ops.js",
+        context: 12,
+      })
+    );
+  });
+
+  it("commits the index from the overview, never the whole tree", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+
+    // The box exists only because a file is staged — with a clean index there
+    // is nothing this button could mean.
+    const box = await screen.findByTestId("lane-changes-commit");
+    await user.type(screen.getByLabelText("Commit message"), "fix: the staged half");
+    await user.click(screen.getByRole("button", { name: "Commit 1 staged" }));
+
+    expect(box).toBeInTheDocument();
+    expect(api.lanes.gitAction).toHaveBeenCalledWith(7, "commit", {
+      message: "fix: the staged half",
+      only: "staged",
+    });
+  });
+
+  it("hides the commit box when nothing is staged", async () => {
+    vi.mocked(api.lanes.changes).mockResolvedValue(
+      changes({
+        files: [
+          {
+            path: "server/lib/git-ops.js",
+            status: " M",
+            untracked: false,
+            unstaged: true,
+            added: 1,
+            deleted: 0,
+            binary: false,
+          },
+        ],
+      })
+    );
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    expect(screen.queryByTestId("lane-changes-commit")).toBeNull();
+  });
+
+  it("puts Files first in the mode row", async () => {
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    const modes = ["Files", "Overview", "Review", "History"].map((name) =>
+      screen.getByRole("button", { name })
+    );
+    // Source order is the reading order here, so comparing positions pins it.
+    for (let i = 1; i < modes.length; i += 1) {
+      expect(
+        modes[i - 1]!.compareDocumentPosition(modes[i]!) & Node.DOCUMENT_POSITION_FOLLOWING
+      ).toBeTruthy();
+    }
+  });
+
+  it("folds one file shut in review mode, and all of them at once", async () => {
+    const user = userEvent.setup();
+    const withHunks = changes({
+      files: [
+        {
+          path: "server/lib/git-ops.js",
+          status: " M",
+          untracked: false,
+          added: 1,
+          deleted: 1,
+          binary: false,
+          hunks: [HUNK],
+        },
+        {
+          path: "notes.txt",
+          status: "??",
+          untracked: true,
+          added: 1,
+          deleted: 0,
+          binary: false,
+          hunks: [HUNK],
+        },
+      ],
+    });
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    vi.mocked(api.lanes.changes).mockResolvedValue(withHunks);
+    await user.click(screen.getByRole("button", { name: "Review" }));
+    await screen.findByTestId("lane-changes-review");
+    expect(screen.getAllByTestId("lane-diff-view")).toHaveLength(2);
+
+    await user.click(screen.getByRole("button", { name: "Collapse server/lib/git-ops.js" }));
+    expect(screen.getAllByTestId("lane-diff-view")).toHaveLength(1);
+    // The header stays, so a folded file is still a row you can reopen.
+    expect(
+      screen.getByRole("button", { name: "Expand server/lib/git-ops.js" })
+    ).toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "Collapse every file" }));
+    expect(screen.queryAllByTestId("lane-diff-view")).toHaveLength(0);
+
+    await user.click(screen.getByRole("button", { name: "Expand every file" }));
+    expect(screen.getAllByTestId("lane-diff-view")).toHaveLength(2);
+  });
+
+  it("opens a file only from its path, and folds it from anywhere else", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    await user.click(screen.getByRole("button", { name: "Review" }));
+    await screen.findByTestId("lane-changes-review");
+
+    // Anywhere on the header but the path: fold, do not navigate.
+    await user.click(screen.getByRole("button", { name: "Collapse server/lib/git-ops.js" }));
+    expect(screen.getByTestId("lane-changes-review")).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: "Expand server/lib/git-ops.js" })
+    ).toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "server/lib/git-ops.js" }));
+    await waitFor(() =>
+      expect(api.lanes.changes).toHaveBeenCalledWith(7, {
+        range: "work",
+        path: "server/lib/git-ops.js",
+        context: 3,
+      })
+    );
+  });
+
+  it("goes back to the list it came from, at the offset it was left at", async () => {
+    const user = userEvent.setup();
+    render(<LaneChangesPanel laneId={7} />);
+    await screen.findByTestId("lane-changes-overview");
+    await user.click(screen.getByRole("button", { name: "Review" }));
+    await screen.findByTestId("lane-changes-review");
+
+    // jsdom lays nothing out, so the scrollable box is described by hand —
+    // the restore deliberately waits until the list is tall enough again.
+    const body = screen.getByTestId("lane-changes-body");
+    Object.defineProperty(body, "scrollHeight", { value: 2000, configurable: true });
+    Object.defineProperty(body, "clientHeight", { value: 400, configurable: true });
+    body.scrollTop = 640;
+
+    await user.click(screen.getByRole("button", { name: "server/lib/git-ops.js" }));
+    await screen.findByRole("button", { name: /All files/ });
+
+    await user.click(screen.getByRole("button", { name: /All files/ }));
+    // Back to REVIEW (where the file was opened from), not to the overview.
+    expect(await screen.findByTestId("lane-changes-review")).toBeInTheDocument();
+    expect(screen.getByTestId("lane-changes-body").scrollTop).toBe(640);
+  });
+});

client/src/components/lanes/__tests__/LaneDiffView.test.tsx

@@ -0,0 +1,74 @@
+/**
+ * @file LaneDiffView.test.tsx
+ * @description Pins the side-by-side renderer: two independently scrolling
+ * columns (a long line must be reachable, not painted over its neighbour)
+ * whose horizontal scroll is mirrored, so the two halves of a line stay
+ * opposite each other.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { LaneDiffView } from "../LaneDiffView";
+import type { LaneChangeFile } from "../../../lib/types";
+
+const FILE: LaneChangeFile = {
+  path: "server/lib/git-ops.js",
+  status: " M",
+  untracked: false,
+  added: 1,
+  deleted: 1,
+  binary: false,
+  hunks: [
+    {
+      header: "@@ -1,2 +1,2 @@",
+      context: "",
+      oldStart: 1,
+      newStart: 1,
+      lines: [
+        { type: "del", oldLine: 1, newLine: null, text: `const x = "${"a".repeat(400)}";` },
+        { type: "add", oldLine: null, newLine: 1, text: `const x = "${"b".repeat(400)}";` },
+      ],
+    },
+  ],
+};
+
+describe("LaneDiffView — side by side", () => {
+  it("gives each column its own scroller", () => {
+    render(<LaneDiffView file={FILE} layout="split" />);
+    expect(screen.getByTestId("lane-diff-split-left").className).toContain("overflow-auto");
+    expect(screen.getByTestId("lane-diff-split-right").className).toContain("overflow-auto");
+  });
+
+  it("bounds its own height so the horizontal bar stays on screen", () => {
+    // A stacked review list caps each file; the single-file view takes the
+    // height its parent gives it. Either way the diff scrolls itself rather
+    // than growing a 2000-line container whose scrollbar is off the bottom.
+    const { rerender } = render(<LaneDiffView file={FILE} layout="unified" />);
+    expect(screen.getByTestId("lane-diff-view").className).toContain("max-h-[60vh]");
+
+    rerender(<LaneDiffView file={FILE} layout="unified" fill />);
+    expect(screen.getByTestId("lane-diff-view").className).toContain("flex-1");
+    expect(screen.getByTestId("lane-diff-view").className).not.toContain("max-h-[60vh]");
+  });
+
+  it("mirrors one column's horizontal scroll onto the other", () => {
+    render(<LaneDiffView file={FILE} layout="split" />);
+    const left = screen.getByTestId("lane-diff-split-left");
+    const right = screen.getByTestId("lane-diff-split-right");
+
+    left.scrollLeft = 320;
+    fireEvent.scroll(left);
+    expect(right.scrollLeft).toBe(320);
+
+    right.scrollLeft = 0;
+    fireEvent.scroll(right);
+    expect(left.scrollLeft).toBe(0);
+  });
+
+  it("keeps the unified layout on one scroller", () => {
+    render(<LaneDiffView file={FILE} layout="unified" />);
+    expect(screen.queryByTestId("lane-diff-split-left")).toBeNull();
+    expect(screen.getByTestId("lane-diff-view").className).toContain("overflow-auto");
+  });
+});

client/src/components/lanes/__tests__/LaneGitBar.test.tsx

@@ -0,0 +1,175 @@
+/**
+ * @file LaneGitBar.test.tsx
+ * @description Pins the lane git action row: the ahead/behind readout, which
+ * buttons a repo with no remote may press, that commit sends the typed
+ * message, that a dirty tree blocks the branch switch client-side (the server
+ * refuses it too), and that a failed action shows git's own words rather than
+ * a generic sentence.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { LaneGitBar } from "../LaneGitBar";
+import { api } from "../../../lib/api";
+import type { LaneGitFacts } from "../../../lib/types";
+
+vi.mock("../../../lib/api", () => ({
+  api: { lanes: { gitAction: vi.fn(), gitBranches: vi.fn() } },
+}));
+
+function facts(over: Partial<Extract<LaneGitFacts, { available: true }>> = {}): LaneGitFacts {
+  return {
+    available: true,
+    branch: "feat/thing",
+    head: "9b3e74a",
+    subject: "wip",
+    dirty: 2,
+    untracked: 1,
+    files: [],
+    hasRemote: true,
+    upstream: "origin/feat/thing",
+    ahead: 2,
+    behind: 1,
+    ...over,
+  };
+}
+
+beforeEach(() => {
+  vi.mocked(api.lanes.gitAction).mockReset().mockResolvedValue({
+    action: "fetch",
+    ok: true,
+    output: "",
+  });
+  vi.mocked(api.lanes.gitBranches)
+    .mockReset()
+    .mockResolvedValue({
+      available: true,
+      branches: ["development", "feat/thing"],
+      current: "feat/thing",
+      worktrees: [],
+    });
+});
+
+describe("LaneGitBar", () => {
+  it("shows both sides of the upstream comparison", () => {
+    render(<LaneGitBar laneId={3} git={facts()} onChanged={vi.fn()} />);
+    const tracking = screen.getByTestId("lane-git-tracking");
+    expect(tracking).toHaveTextContent("2");
+    expect(tracking).toHaveTextContent("1");
+  });
+
+  it("disables the network actions when the repo has no remote", () => {
+    render(
+      <LaneGitBar
+        laneId={3}
+        git={facts({ hasRemote: false, upstream: null })}
+        onChanged={vi.fn()}
+      />
+    );
+    expect(screen.getByRole("button", { name: /Fetch/ })).toBeDisabled();
+    expect(screen.getByRole("button", { name: /Push/ })).toBeDisabled();
+    // Local actions stay available — a repo with no remote still commits.
+    expect(screen.getByRole("button", { name: /^Commit$/ })).toBeEnabled();
+  });
+
+  it("commits with the typed message and reports the change upward", async () => {
+    const user = userEvent.setup();
+    const onChanged = vi.fn();
+    render(<LaneGitBar laneId={3} git={facts()} onChanged={onChanged} />);
+
+    await user.click(screen.getByRole("button", { name: /^Commit$/ }));
+    await user.type(screen.getByLabelText("Commit message"), "fix: the thing");
+    await user.click(screen.getByRole("button", { name: /Commit 3 files/ }));
+
+    await waitFor(() =>
+      expect(api.lanes.gitAction).toHaveBeenCalledWith(3, "commit", { message: "fix: the thing" })
+    );
+    expect(onChanged).toHaveBeenCalled();
+  });
+
+  it("offers no commit when nothing is uncommitted", () => {
+    render(<LaneGitBar laneId={3} git={facts({ dirty: 0, untracked: 0 })} onChanged={vi.fn()} />);
+    expect(screen.getByRole("button", { name: /^Commit$/ })).toBeDisabled();
+  });
+
+  it("loads the branch list on demand and refuses to switch while dirty", async () => {
+    const user = userEvent.setup();
+    render(<LaneGitBar laneId={3} git={facts()} onChanged={vi.fn()} />);
+
+    await user.click(screen.getByRole("button", { name: /Branch/ }));
+    await waitFor(() => expect(api.lanes.gitBranches).toHaveBeenCalledWith(3));
+    await user.selectOptions(await screen.findByLabelText("Switch branch…"), "development");
+    // Picking is harmless; applying is what a dirty tree blocks.
+    expect(screen.getByRole("button", { name: "Switch branch" })).toBeDisabled();
+    expect(api.lanes.gitAction).not.toHaveBeenCalled();
+  });
+
+  it("switches branch on a clean tree", async () => {
+    const user = userEvent.setup();
+    render(<LaneGitBar laneId={3} git={facts({ dirty: 0, untracked: 0 })} onChanged={vi.fn()} />);
+
+    await user.click(screen.getByRole("button", { name: /Branch/ }));
+    const select = await screen.findByLabelText("Switch branch…");
+    await user.selectOptions(select, "development");
+    await user.click(screen.getByRole("button", { name: "Switch branch" }));
+
+    await waitFor(() =>
+      expect(api.lanes.gitAction).toHaveBeenCalledWith(3, "switch", { branch: "development" })
+    );
+  });
+
+  it("creates a branch without switching, then offers a sibling lane on it", async () => {
+    const user = userEvent.setup();
+    const onNewLane = vi.fn();
+    render(
+      <LaneGitBar
+        laneId={3}
+        git={facts({ dirty: 0, untracked: 0 })}
+        onChanged={vi.fn()}
+        onNewLane={onNewLane}
+      />
+    );
+
+    await user.click(screen.getByRole("button", { name: /Branch/ }));
+    await user.type(await screen.findByLabelText("New branch name…"), "feat/sibling");
+    await user.click(screen.getByRole("button", { name: "Create" }));
+    await waitFor(() =>
+      expect(api.lanes.gitAction).toHaveBeenCalledWith(3, "branch-create", {
+        branch: "feat/sibling",
+      })
+    );
+
+    await user.selectOptions(screen.getByLabelText("Switch branch…"), "development");
+    await user.click(screen.getByRole("button", { name: "New lane here" }));
+    expect(onNewLane).toHaveBeenCalledWith("development");
+  });
+
+  it("commits only the index when asked", async () => {
+    const user = userEvent.setup();
+    render(<LaneGitBar laneId={3} git={facts()} onChanged={vi.fn()} />);
+
+    await user.click(screen.getByRole("button", { name: /^Commit$/ }));
+    await user.type(screen.getByLabelText(/Commit message/), "fix: staged only");
+    await user.click(screen.getByRole("button", { name: "Commit staged" }));
+
+    await waitFor(() =>
+      expect(api.lanes.gitAction).toHaveBeenCalledWith(3, "commit", {
+        message: "fix: staged only",
+        only: "staged",
+      })
+    );
+  });
+
+  it("prints git's own rejection text when an action fails", async () => {
+    const user = userEvent.setup();
+    vi.mocked(api.lanes.gitAction).mockRejectedValue(
+      new Error("git push failed\n! [rejected] main -> main (non-fast-forward)")
+    );
+    render(<LaneGitBar laneId={3} git={facts()} onChanged={vi.fn()} />);
+
+    await user.click(screen.getByRole("button", { name: /Push/ }));
+    expect(await screen.findByTestId("lane-git-bar-error")).toHaveTextContent("non-fast-forward");
+  });
+});

client/src/components/run/RunSetup.tsx

@@ -36,6 +36,7 @@ import {
   ShieldAlert,
   X,
   FolderOpen,
+  GitBranch,
   Home,
   History as HistoryIcon,
   Search,
@@ -449,7 +450,10 @@ export function CwdAutocomplete({
   // Group suggestions by kind preserving fixed order — home first, matching
   // the neutral default the page pre-fills (issue #202).
   const groups = useMemo(() => {
-    const order: CwdSuggestion["kind"][] = ["home", "dashboard", "recent"];
+    // "repo" (source repos lanes were cut from) sits above the recents: on the
+    // Add-lane form it is the group the field is actually asking for, and on
+    // the Run form it is a short, deliberate list rather than history.
+    const order: CwdSuggestion["kind"][] = ["home", "dashboard", "repo", "recent"];
     return order
       .map((kind) => ({ kind, items: filtered.filter((s) => s.kind === kind) }))
       .filter((g) => g.items.length > 0);
@@ -525,6 +529,8 @@ export function CwdAutocomplete({
                     <FolderOpen className="w-3 h-3" />
                   ) : g.kind === "home" ? (
                     <Home className="w-3 h-3" />
+                  ) : g.kind === "repo" ? (
+                    <GitBranch className="w-3 h-3" />
                   ) : (
                     <HistoryIcon className="w-3 h-3" />
                   )}

client/src/components/workflows/CompactionImpact.tsx

@@ -407,7 +407,7 @@ export function CompactionImpact({ data }: CompactionImpactProps) {
       {/* Hover tooltip (matches the app's other chart tooltips) */}
       {tip && (
         <div
-          className="fixed z-50 pointer-events-none rounded-md border border-[#2a2a4a] bg-[#12121f] px-2.5 py-1.5 text-xs shadow-xl"
+          className="fixed z-50 pointer-events-none rounded-md border border-border bg-surface-2 px-2.5 py-1.5 text-xs shadow-xl"
           style={{
             left: tip.x > window.innerWidth - 220 ? tip.x - 14 : tip.x + 14,
             top: tip.y - 10,

client/src/components/workflows/OrchestrationDAG.tsx

@@ -853,7 +853,7 @@ export function OrchestrationDAG({ data, onNodeClick, selectedNode }: Orchestrat
         ref={tipRef}
         role="tooltip"
         aria-hidden="true"
-        className="fixed z-50 px-3 py-2 bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-2xl pointer-events-none"
+        className="fixed z-50 px-3 py-2 bg-surface-2 border border-border rounded-lg shadow-2xl pointer-events-none"
         style={{
           display: "none",
           opacity: 0,
@@ -922,10 +922,11 @@ function buildDAGTooltipContent(el: HTMLDivElement, node: DAGNode, t: TFn) {
     row.style.cssText =
       "display:flex;justify-content:space-between;gap:16px;font-size:11px;line-height:1.6";
     const lbl = document.createElement("span");
-    lbl.style.color = "#64748b";
+    lbl.style.color = "rgb(var(--fg-muted))";
     lbl.textContent = label;
     const val = document.createElement("span");
-    val.style.cssText = "color:#cbd5e1;font-weight:500;font-variant-numeric:tabular-nums";
+    val.style.cssText =
+      "color:rgb(var(--fg-primary));font-weight:500;font-variant-numeric:tabular-nums";
     val.textContent = value;
     row.appendChild(lbl);
     row.appendChild(val);
@@ -935,12 +936,12 @@ function buildDAGTooltipContent(el: HTMLDivElement, node: DAGNode, t: TFn) {
 
   const desc = document.createElement("p");
   desc.style.cssText =
-    "font-size:11px;color:#94a3b8;line-height:1.45;border-top:1px solid #2a2a4a;padding-top:8px;margin:0";
+    "font-size:11px;color:rgb(var(--fg-secondary));line-height:1.45;border-top:1px solid rgb(var(--border));padding-top:8px;margin:0";
   desc.textContent = meta.description;
   el.appendChild(desc);
 
   const hint = document.createElement("p");
-  hint.style.cssText = "font-size:10px;color:#64748b;line-height:1.45;margin:6px 0 0";
+  hint.style.cssText = "font-size:10px;color:rgb(var(--fg-muted));line-height:1.45;margin:6px 0 0";
   hint.textContent = t("orchestration.tooltip.tipClickToFilter");
   el.appendChild(hint);
 }

client/src/components/workflows/SessionComplexityScatter.tsx

@@ -115,7 +115,7 @@ function Tooltip({ state }: { state: TooltipState }) {
 
   return (
     <div
-      className="fixed z-50 px-3 py-2 text-xs bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-xl text-fg-secondary pointer-events-none whitespace-nowrap"
+      className="fixed z-50 px-3 py-2 text-xs bg-surface-2 border border-border rounded-lg shadow-xl text-fg-secondary pointer-events-none whitespace-nowrap"
       style={{
         left: nearRight ? state.x - 12 : state.x + 12,
         top: state.y - 10,
@@ -144,7 +144,7 @@ function Tooltip({ state }: { state: TooltipState }) {
           </span>
         )}
       </div>
-      <div className="mt-1 pt-1 border-t border-[#2a2a4a]">
+      <div className="mt-1 pt-1 border-t border-border">
         <span className="font-medium" style={{ color: statusColor(state.item.status) }}>
           {t(`common:status.${state.item.status}`, { defaultValue: state.item.status })}
         </span>

client/src/components/workflows/WorkflowStats.tsx

@@ -230,10 +230,10 @@ function InfoPopover({ calculationKey, interp, valueDisplay, metricPhraseKey }:
         <div
           ref={popoverRef}
           role="tooltip"
-          className="fixed z-50 p-3 bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
+          className="fixed z-50 p-3 bg-surface-2 border border-border rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
           style={{ left: coords.left, top: coords.top, width: POPOVER_W }}
         >
-          <div className="flex items-baseline gap-2 mb-2 pb-2 border-b border-[#2a2a4a]">
+          <div className="flex items-baseline gap-2 mb-2 pb-2 border-b border-border">
             <span className="text-base font-semibold text-fg-primary tabular-nums">
               {valueDisplay}
             </span>

client/src/i18n/locales/en/lanes.json

@@ -22,13 +22,19 @@
   "add": "Add lane",
   "addLane": "Create a lane from a working directory",
   "addLaneBaseLabel": "Branch to fork from",
-  "addLaneBranchHint": "Must be a valid, not-yet-existing git branch name.",
+  "addLaneBranchBusy": "{{branch}} — already checked out at {{path}}",
+  "addLaneBranchExistingHint": "The worktree checks this branch out as it is — no new branch, no base.",
+  "addLaneBranchExistingLabel": "Branch to check out",
+  "addLaneBranchHintAuto": "Leave empty to use the default name shown above.",
   "addLaneBranchLabel": "New branch name",
+  "addLaneBranchModeCurrent": "Current branch",
+  "addLaneBranchModeCurrentHint": "Work straight on this repo's checked-out branch (main) — no worktree, no fork. Switches to Repo mode.",
+  "addLaneBranchModeExisting": "Existing branch",
+  "addLaneBranchModeNew": "New branch",
   "addLaneBranchPlaceholder": "feat/my-feature",
   "addLaneNoBranches": "This repo has no commits yet — the worktree will start empty.",
+  "addLaneNoFreeBranches": "Every branch in this repo is already checked out in a worktree. Create a new branch instead.",
   "addLaneNotARepo": "Not a git repository (or no read access) yet.",
-  "addLanePipelineHint": "Which stages this lane's map shows. Pick the one the skill driving it declares against — nothing else in this UI changes it later.",
-  "addLanePipelineLabel": "Pipeline template",
   "addLaneProvisionFailed": "Worktree provisioning failed or timed out — the lane exists but auto-setup was skipped. Check the lane's git facts, then run agents/mcp setup manually.",
   "addLaneRepoHint": "An existing git repo. The dashboard creates a new worktree for the lane, not a folder you pick.",
   "addLaneRepoHintAdopt": "An existing directory. The dashboard tracks it as-is — no worktree, no new branch.",
@@ -52,11 +58,63 @@
   "addLaneToolClaude": "Claude Code",
   "addLaneToolCodex": "Codex",
   "addLaneToolHint": "Which CLI drives this lane. Cannot be changed later.",
-  "autoStage": "auto: {{stage}}",
+  "addLaneWorktreeDetached": "(detached)",
+  "addLaneWorktreesMore": "+{{count}} more",
+  "addLaneWorktreesTitle": "Worktrees of this repo ({{count}})",
   "browse.button": "Browse",
   "browse.empty": "This folder is empty.",
   "browse.select": "Select this folder",
   "browse.title": "Browse for a folder",
+  "changes.back": "All files",
+  "changes.bin": "bin",
+  "changes.binary": "Binary file — not shown.",
+  "changes.collapse": "Collapse the changes panel",
+  "changes.collapseAll": "Collapse every file",
+  "changes.collapseAllFolders": "Collapse all folders",
+  "changes.collapseContext": "Show fewer surrounding lines",
+  "changes.collapseFile": "Collapse {{path}}",
+  "changes.commitPlaceholder": "Commit message",
+  "changes.commitStaged": "Commit {{count}} staged",
+  "changes.conflicted": "conflict",
+  "changes.discard": "Discard this file's changes",
+  "changes.discardConfirm": "Click again to discard — this cannot be undone",
+  "changes.empty.branch": "This branch matches its base.",
+  "changes.empty.commit": "This commit changed no files.",
+  "changes.empty.work": "Nothing uncommitted.",
+  "changes.expand": "Show the changes panel",
+  "changes.expandAll": "Expand every file",
+  "changes.expandAllFolders": "Expand all folders",
+  "changes.expandContext": "Show more surrounding lines",
+  "changes.expandFile": "Expand {{path}}",
+  "changes.fileGone": "That file no longer has changes in this range.",
+  "changes.fileTruncated": "Diff cut short — open the file in an editor for the rest.",
+  "changes.layout.split": "Side-by-side",
+  "changes.layout.unified": "Unified",
+  "changes.loading": "Reading the working copy…",
+  "changes.mode.browse": "Files",
+  "changes.mode.history": "History",
+  "changes.mode.overview": "Overview",
+  "changes.mode.review": "Review",
+  "changes.noCommits": "No commits yet.",
+  "changes.noHunks": "No textual change.",
+  "changes.noMatches": "No tracked file matches.",
+  "changes.openFile": "Open {{path}}",
+  "changes.quickOpen": "Find a file by path…",
+  "changes.range.branch": "vs base",
+  "changes.range.branchHint": "base...HEAD — everything this lane's branch adds on top of its base",
+  "changes.range.work": "Uncommitted",
+  "changes.range.workHint": "Working tree vs HEAD — what has been touched and not committed",
+  "changes.refresh": "Refresh",
+  "changes.resize": "Resize the changes panel (next: {{size}})",
+  "changes.size.compact": "Narrow",
+  "changes.size.half": "50 / 50",
+  "changes.size.wide": "70 / 30",
+  "changes.stage": "Stage this file",
+  "changes.title": "Changes",
+  "changes.truncated": "Some changes were left out to keep this panel responsive.",
+  "changes.unavailable": "This lane's directory is not a readable git repository.",
+  "changes.unstage": "Unstage this file",
+  "changes.wholeFile": "Whole file",
   "confirmRemoveCancel": "Cancel",
   "confirmRemoveConfirm": "Remove",
   "confirmRemoveMessage": "This action cannot be undone.",
@@ -94,7 +152,7 @@
   "destructive.reset.survives": "Gitignored files such as node_modules and .env are kept; untracked files are deleted.",
   "destructive.reset.title": "Reset managed worktree?",
   "destructive.warning.no-remote": "No Git remote is configured, so nothing here is backed up remotely. You can still proceed.",
-  "empty.body": "A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Add one here, or from a terminal:",
+  "empty.body": "A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Click anywhere on this card to add one, or from a terminal:",
   "empty.title": "No lanes yet",
   "features.archived": "archived",
   "features.live": "Live",
@@ -105,6 +163,36 @@
   "git.filesMore_other": "… and {{count}} more files",
   "git.noDelta": "new",
   "git.uncommitted": "{{dirty}} modified · {{untracked}} untracked",
+  "gitBar.branchCreate": "Create",
+  "gitBar.branchCreateHint": "Create this branch without switching to it",
+  "gitBar.branchDelete": "Delete",
+  "gitBar.branchDeleteHint": "Delete the selected branch (refused if it has unmerged commits)",
+  "gitBar.branchNewPlaceholder": "New branch name…",
+  "gitBar.cancel": "Cancel",
+  "gitBar.commit": "Commit",
+  "gitBar.commitAll_one": "Commit {{count}} file",
+  "gitBar.commitAll_other": "Commit {{count}} files",
+  "gitBar.commitHint": "Stage everything and commit",
+  "gitBar.commitNothing": "Nothing to commit",
+  "gitBar.commitPlaceholder": "Commit message",
+  "gitBar.commitStaged": "Commit staged",
+  "gitBar.commitStagedHint": "Commit only what is staged in the Changes panel",
+  "gitBar.fetch": "Fetch",
+  "gitBar.fetchHint": "git fetch --all --prune",
+  "gitBar.inSync": "in sync",
+  "gitBar.newLane": "New lane here",
+  "gitBar.newLaneHint": "Open Add lane for a sibling worktree on the selected branch",
+  "gitBar.noUpstream": "not pushed",
+  "gitBar.pull": "Pull",
+  "gitBar.pullHint": "git pull --ff-only — refuses instead of merging when the branch has diverged",
+  "gitBar.push": "Push",
+  "gitBar.pushHint": "git push -u origin HEAD",
+  "gitBar.switch": "Branch",
+  "gitBar.switchApply": "Switch branch",
+  "gitBar.switchCurrent": "current",
+  "gitBar.switchDirty": "Commit or discard the uncommitted changes first",
+  "gitBar.switchHint": "Switch this worktree to another local branch",
+  "gitBar.switchLabel": "Switch branch…",
   "kind.adopted": "adopted",
   "kind.managed": "managed",
   "laneDetail.hide": "Hide details",
@@ -142,7 +230,6 @@
   "splitView.paneCount": "{{count}} pane",
   "splitView.paneLaneLabel": "Pane lane selector",
   "splitView.pickLane": "Pick a lane",
-  "stageUndeclared": "not declared",
   "status.failed": "failed",
   "status.idle": "idle",
   "status.provisioning": "provisioning",

client/src/i18n/locales/en/run.json

@@ -61,6 +61,7 @@
     "cwdGroups": {
       "dashboard": "Dashboard server",
       "home": "Home",
+      "repo": "Source repos",
       "recent": "Recent - used by Claude Code"
     },
     "cwdHint": "Absolute path. Defaults to the dashboard's own cwd.",

client/src/i18n/locales/vi/lanes.json

@@ -22,13 +22,19 @@
   "add": "Thêm lane",
   "addLane": "Tạo lane từ một thư mục làm việc",
   "addLaneBaseLabel": "Nhánh để tạo nhánh mới",
-  "addLaneBranchHint": "Phải là tên nhánh git hợp lệ và chưa tồn tại.",
+  "addLaneBranchBusy": "{{branch}} — đang được checkout tại {{path}}",
+  "addLaneBranchExistingHint": "Worktree checkout đúng nhánh này — không tạo nhánh mới, không cần nhánh gốc.",
+  "addLaneBranchExistingLabel": "Nhánh cần checkout",
+  "addLaneBranchHintAuto": "Để trống để dùng tên mặc định hiển thị ở trên.",
   "addLaneBranchLabel": "Tên nhánh mới",
+  "addLaneBranchModeCurrent": "Nhánh hiện tại",
+  "addLaneBranchModeCurrentHint": "Làm thẳng trên nhánh repo đang mở (main) — không tạo worktree, không fork nhánh. Chuyển sang chế độ Repo.",
+  "addLaneBranchModeExisting": "Nhánh có sẵn",
+  "addLaneBranchModeNew": "Nhánh mới",
   "addLaneBranchPlaceholder": "feat/tinh-nang-cua-toi",
   "addLaneNoBranches": "Repo này chưa có commit nào — worktree sẽ bắt đầu trống.",
+  "addLaneNoFreeBranches": "Mọi nhánh của repo này đều đang nằm trong một worktree. Hãy tạo nhánh mới.",
   "addLaneNotARepo": "Chưa phải repo git (hoặc không có quyền đọc).",
-  "addLanePipelineHint": "Bản đồ lane này sẽ hiện những stage nào. Chọn đúng cái mà skill điều khiển nó khai báo — sau này không màn hình nào đổi được.",
-  "addLanePipelineLabel": "Mẫu pipeline",
   "addLaneProvisionFailed": "Tạo worktree thất bại hoặc quá thời gian chờ — lane vẫn tồn tại nhưng tự động thiết lập đã bị bỏ qua. Kiểm tra git facts của lane, rồi chạy thiết lập agents/mcp thủ công.",
   "addLaneRepoHint": "Một repo git có sẵn. Dashboard tự tạo worktree mới cho lane, không phải thư mục bạn chọn.",
   "addLaneRepoHintAdopt": "Một thư mục có sẵn. Dashboard theo dõi nguyên trạng — không tạo worktree, không tạo nhánh mới.",
@@ -52,11 +58,63 @@
   "addLaneToolClaude": "Claude Code",
   "addLaneToolCodex": "Codex",
   "addLaneToolHint": "CLI nào điều khiển lane này. Không thể thay đổi sau này.",
-  "autoStage": "tự động: {{stage}}",
+  "addLaneWorktreeDetached": "(detached)",
+  "addLaneWorktreesMore": "+{{count}} nữa",
+  "addLaneWorktreesTitle": "Worktree của repo này ({{count}})",
   "browse.button": "Duyệt",
   "browse.empty": "Thư mục này trống.",
   "browse.select": "Chọn thư mục này",
   "browse.title": "Duyệt chọn thư mục",
+  "changes.back": "Tất cả file",
+  "changes.bin": "bin",
+  "changes.binary": "File nhị phân — không hiển thị.",
+  "changes.collapse": "Thu gọn bảng thay đổi",
+  "changes.collapseAll": "Thu gọn tất cả file",
+  "changes.collapseAllFolders": "Thu gọn tất cả thư mục",
+  "changes.collapseContext": "Bớt dòng xung quanh",
+  "changes.collapseFile": "Thu gọn {{path}}",
+  "changes.commitPlaceholder": "Nội dung commit",
+  "changes.commitStaged": "Commit {{count}} file đã stage",
+  "changes.conflicted": "xung đột",
+  "changes.discard": "Bỏ thay đổi của file này",
+  "changes.discardConfirm": "Bấm lần nữa để bỏ — không thể hoàn tác",
+  "changes.empty.branch": "Nhánh này không khác nhánh gốc.",
+  "changes.empty.commit": "Commit này không đổi file nào.",
+  "changes.empty.work": "Không có gì chưa commit.",
+  "changes.expand": "Mở bảng thay đổi",
+  "changes.expandAll": "Mở tất cả file",
+  "changes.expandAllFolders": "Mở tất cả thư mục",
+  "changes.expandContext": "Hiện thêm dòng xung quanh",
+  "changes.expandFile": "Mở {{path}}",
+  "changes.fileGone": "File này không còn thay đổi nào trong phạm vi đang xem.",
+  "changes.fileTruncated": "Diff bị cắt bớt — mở file trong editor để xem phần còn lại.",
+  "changes.layout.split": "Hai cột",
+  "changes.layout.unified": "Một cột",
+  "changes.loading": "Đang đọc working copy…",
+  "changes.mode.browse": "Tệp",
+  "changes.mode.history": "Lịch sử",
+  "changes.mode.overview": "Tổng quan",
+  "changes.mode.review": "Xem toàn bộ",
+  "changes.noCommits": "Chưa có commit nào.",
+  "changes.noHunks": "Không có thay đổi nội dung.",
+  "changes.noMatches": "Không có file nào khớp.",
+  "changes.openFile": "Mở {{path}}",
+  "changes.quickOpen": "Tìm file theo đường dẫn…",
+  "changes.range.branch": "So nhánh gốc",
+  "changes.range.branchHint": "base...HEAD — toàn bộ phần nhánh của lane này thêm vào so với nhánh gốc",
+  "changes.range.work": "Chưa commit",
+  "changes.range.workHint": "Working tree so với HEAD — những gì vừa sửa mà chưa commit",
+  "changes.refresh": "Tải lại",
+  "changes.resize": "Đổi độ rộng khung changes (kế tiếp: {{size}})",
+  "changes.size.compact": "Hẹp",
+  "changes.size.half": "50 / 50",
+  "changes.size.wide": "70 / 30",
+  "changes.stage": "Đưa file này vào index",
+  "changes.title": "Thay đổi",
+  "changes.truncated": "Một phần thay đổi đã bị lược bớt để bảng này còn mượt.",
+  "changes.unavailable": "Thư mục của lane này không phải repo git đọc được.",
+  "changes.unstage": "Bỏ file này khỏi index",
+  "changes.wholeFile": "Toàn bộ file",
   "confirmRemoveCancel": "Hủy",
   "confirmRemoveConfirm": "Xóa",
   "confirmRemoveMessage": "Hành động này không thể hoàn tác.",
@@ -94,7 +152,7 @@
   "destructive.reset.survives": "Các tệp Git bỏ qua như node_modules và .env được giữ lại; các tệp chưa theo dõi sẽ bị xóa.",
   "destructive.reset.title": "Đặt lại worktree được quản lý?",
   "destructive.warning.no-remote": "Chưa cấu hình Git remote, nên không có bản sao lưu ở xa. Bạn vẫn có thể tiếp tục.",
-  "empty.body": "Mỗi lane là một thư mục làm việc mà dashboard theo dõi — pipeline, session và terminal của nó. Thêm ở đây, hoặc từ terminal:",
+  "empty.body": "Mỗi lane là một thư mục làm việc mà dashboard theo dõi — pipeline, session và terminal của nó. Bấm vào bất kỳ đâu trên ô này để thêm, hoặc từ terminal:",
   "empty.title": "Chưa có lane nào",
   "features.archived": "đã lưu trữ",
   "features.live": "Phiên bản trực tiếp",
@@ -105,6 +163,36 @@
   "git.filesMore_other": "… và {{count}} tệp nữa",
   "git.noDelta": "mới",
   "git.uncommitted": "{{dirty}} đã sửa · {{untracked}} chưa theo dõi",
+  "gitBar.branchCreate": "Tạo",
+  "gitBar.branchCreateHint": "Tạo nhánh này mà không chuyển sang",
+  "gitBar.branchDelete": "Xoá",
+  "gitBar.branchDeleteHint": "Xoá nhánh đang chọn (git từ chối nếu còn commit chưa merge)",
+  "gitBar.branchNewPlaceholder": "Tên nhánh mới…",
+  "gitBar.cancel": "Huỷ",
+  "gitBar.commit": "Commit",
+  "gitBar.commitAll_one": "Commit {{count}} file",
+  "gitBar.commitAll_other": "Commit {{count}} file",
+  "gitBar.commitHint": "Stage tất cả rồi commit",
+  "gitBar.commitNothing": "Không có gì để commit",
+  "gitBar.commitPlaceholder": "Nội dung commit",
+  "gitBar.commitStaged": "Commit phần đã stage",
+  "gitBar.commitStagedHint": "Chỉ commit những file đã stage ở thẻ Changes",
+  "gitBar.fetch": "Fetch",
+  "gitBar.fetchHint": "git fetch --all --prune",
+  "gitBar.inSync": "đã đồng bộ",
+  "gitBar.newLane": "Tạo lane mới",
+  "gitBar.newLaneHint": "Mở Add lane để tạo worktree anh em trên nhánh đang chọn",
+  "gitBar.noUpstream": "chưa push",
+  "gitBar.pull": "Pull",
+  "gitBar.pullHint": "git pull --ff-only — nhánh đã rẽ nhánh thì báo lỗi chứ không merge",
+  "gitBar.push": "Push",
+  "gitBar.pushHint": "git push -u origin HEAD",
+  "gitBar.switch": "Nhánh",
+  "gitBar.switchApply": "Chuyển nhánh",
+  "gitBar.switchCurrent": "hiện tại",
+  "gitBar.switchDirty": "Hãy commit hoặc bỏ các thay đổi chưa commit trước",
+  "gitBar.switchHint": "Đổi worktree này sang nhánh local khác",
+  "gitBar.switchLabel": "Đổi nhánh…",
   "kind.adopted": "đã nhận",
   "kind.managed": "được quản lý",
   "laneDetail.hide": "Ẩn chi tiết",
@@ -142,7 +230,6 @@
   "splitView.paneCount": "{{count}} ô",
   "splitView.paneLaneLabel": "Bộ chọn lane cho ô",
   "splitView.pickLane": "Chọn lane",
-  "stageUndeclared": "chưa khai báo",
   "status.failed": "thất bại",
   "status.idle": "rảnh",
   "status.provisioning": "đang khởi tạo",

client/src/i18n/locales/vi/run.json

@@ -60,6 +60,7 @@
     "cwdGroups": {
       "dashboard": "Dashboard server",
       "home": "Home",
+      "repo": "Repo nguồn",
       "recent": "Gần đây - Claude Code đã dùng"
     },
     "cwdHint": "Đường dẫn tuyệt đối. Mặc định là cwd của dashboard.",

client/src/lib/api.ts

@@ -396,10 +396,16 @@ import type {
   CostResult,
   DashboardEvent,
   Lane,
+  LaneChangeRange,
+  LaneChanges,
+  LaneCommit,
+  LaneFileContent,
+  LaneTreeEntry,
   LaneCounts,
   LaneGitFacts,
   LaneRuntime,
   LaneTool,
+  LaneWorktree,
   ModelPricing,
   NamedLock,
   PipelineStats,
@@ -500,7 +506,11 @@ export function dashboardToken(): string | null {
  * @returns       The parsed JSON response body, typed as `T`.
  * @throws {Error} When the response status is not ok (non-2xx). The thrown
  *   message is `body.error.message` if the error body parsed as JSON and carried
- *   one, otherwise the literal `HTTP <status>`.
+ *   one, otherwise the literal `HTTP <status>`. The server's own `error.code`
+ *   (e.g. `"ERUNLIVE"`) rides along as `.code` on the thrown error — every
+ *   route's error body carries one (see `server/routes/*.js`), and a caller
+ *   that needs to branch on which error this was should check `.code`, never
+ *   guess at substrings of the human-readable `.message`.
  */
 async function request<T>(path: string, options?: RequestInit): Promise<T> {
   const token = dashboardToken();
@@ -517,7 +527,10 @@ async function request<T>(path: string, options?: RequestInit): Promise<T> {
     // isn't JSON (or json() throws), fall back to an empty object so the `?.`
     // chain below cleanly degrades to the generic `HTTP <status>` message.
     const body = await res.json().catch(() => ({}));
-    throw new Error(body?.error?.message || `HTTP ${res.status}`);
+    throw Object.assign(new Error(body?.error?.message || `HTTP ${res.status}`), {
+      code: body?.error?.code,
+      status: res.status,
+    });
   }
   return res.json();
 }
@@ -2304,11 +2317,13 @@ export const api = {
     /**
      * GET /api/lanes/branches — a candidate source repo's local branches.
      * @param repo Absolute path to an existing git repository.
-     * @returns `{ branches, current }` — local branch names (not `origin/*`)
-     *   and which one is currently checked out (null if detached).
+     * @returns `{ branches, current, worktrees }` — local branch names (not
+     *   `origin/*`), which one is currently checked out (null if detached),
+     *   and the repo's existing worktrees, so the picker can grey out the
+     *   branches git would refuse to check out a second time.
      */
     branches: (repo: string) =>
-      request<{ branches: string[]; current: string | null }>(
+      request<{ branches: string[]; current: string | null; worktrees: LaneWorktree[] }>(
         `/lanes/branches?repo=${encodeURIComponent(repo)}`
       ),
     /**
@@ -2357,6 +2372,129 @@ export const api = {
      * readable git repository, which is a normal state rather than an error.
      */
     git: (id: number) => request<LaneGitFacts>(`/lanes/${id}/git`),
+    /**
+     * GET /api/lanes/:id/git/changes — the lane's code changes, at the depth
+     * the Changes panel asks for.
+     * @param id The lane id.
+     * @param opts `range` picks the comparison (`work` = uncommitted vs HEAD,
+     *   `branch` = base...HEAD). Pass `path` for one file's hunks, or
+     *   `full: true` for every file's; with neither it is a summary.
+     * @returns {@link LaneChanges} — `available: false` for a cwd git cannot read.
+     */
+    changes: (
+      id: number,
+      opts: {
+        range?: LaneChangeRange;
+        path?: string;
+        full?: boolean;
+        sha?: string;
+        context?: number;
+      } = {}
+    ) => {
+      const q = new URLSearchParams();
+      if (opts.range) q.set("range", opts.range);
+      if (opts.path) q.set("path", opts.path);
+      if (opts.full) q.set("full", "1");
+      if (opts.sha) q.set("sha", opts.sha);
+      if (opts.context != null) q.set("context", String(opts.context));
+      return request<LaneChanges>(`/lanes/${id}/git/changes?${q.toString()}`);
+    },
+    /**
+     * GET /api/lanes/:id/git/log — the lane's recent commits, newest first.
+     * @param id The lane id.
+     * @param opts `file` narrows the list to the commits touching one path.
+     */
+    gitLog: (id: number, opts: { limit?: number; file?: string } = {}) => {
+      const q = new URLSearchParams();
+      if (opts.limit) q.set("limit", String(opts.limit));
+      if (opts.file) q.set("file", opts.file);
+      return request<{ available: boolean; commits: LaneCommit[] }>(
+        `/lanes/${id}/git/log?${q.toString()}`
+      );
+    },
+    /**
+     * GET /api/lanes/:id/git/file — one file's whole content at a revision.
+     * @param id The lane id.
+     * @param path Repo-relative path.
+     * @param rev `work` (the file on disk), `HEAD`, or a commit-ish.
+     */
+    gitFile: (id: number, path: string, rev = "work") =>
+      request<LaneFileContent>(
+        `/lanes/${id}/git/file?path=${encodeURIComponent(path)}&rev=${encodeURIComponent(rev)}`
+      ),
+    /**
+     * GET /api/lanes/:id/git/ls — tracked paths matching a substring, for
+     * quick-open. Ignored files never appear (it reads `git ls-files`).
+     * @param id The lane id.
+     * @param q The substring typed into the quick-open box.
+     */
+    gitLs: (id: number, q: string) =>
+      request<{ available: boolean; paths: string[]; truncated: boolean; total: number }>(
+        `/lanes/${id}/git/ls?q=${encodeURIComponent(q)}`
+      ),
+    /**
+     * GET /api/lanes/:id/git/tree — one directory level of tracked files.
+     * @param id The lane id.
+     * @param path Repo-relative directory; "" for the repo root.
+     */
+    gitTree: (id: number, path = "") =>
+      request<{
+        available: boolean;
+        path: string;
+        entries: LaneTreeEntry[];
+        truncated: boolean;
+      }>(`/lanes/${id}/git/tree?path=${encodeURIComponent(path)}`),
+    /**
+     * GET /api/lanes/:id/git/branches — the lane repo's local branches, for
+     * the branch switcher. The repo comes from the lane row, never the query.
+     * @param id The lane id.
+     */
+    gitBranches: (id: number) =>
+      request<{
+        available: boolean;
+        branches: string[];
+        current: string | null;
+        worktrees: LaneWorktree[];
+      }>(`/lanes/${id}/git/branches`),
+    /**
+     * POST /api/lanes/:id/git/:action — one git write on the lane's worktree.
+     * @param id The lane id.
+     * @param action `fetch`, `pull` (always --ff-only), `push`, `stage`,
+     *   `unstage`, `discard`, `commit`, `switch`, `branch-create` or
+     *   `branch-delete`.
+     * @param body `{message, only}` for commit; `{branch, create}` for switch;
+     *   `{branch, base}` for branch-create; `{paths}` for stage/unstage;
+     *   `{paths, confirm: true}` for discard — which is irreversible, so the
+     *   server refuses it without that flag.
+     * @returns `{action, ok, output}` — `output` is git's own text, shown as-is.
+     */
+    gitAction: (
+      id: number,
+      action:
+        | "fetch"
+        | "pull"
+        | "push"
+        | "commit"
+        | "switch"
+        | "stage"
+        | "unstage"
+        | "discard"
+        | "branch-create"
+        | "branch-delete",
+      body: {
+        message?: string;
+        only?: "staged";
+        branch?: string;
+        base?: string;
+        create?: boolean;
+        paths?: string[];
+        confirm?: boolean;
+      } = {}
+    ) =>
+      request<{ action: string; ok: true; output: string; branch?: string }>(
+        `/lanes/${id}/git/${action}`,
+        { method: "POST", body: JSON.stringify(body) }
+      ),
     /**
      * GET /api/lanes/:id/runtime — the lane's own application stack: slot,
      * ports, service liveness, and the last boot error.
@@ -3476,7 +3614,7 @@ export interface DashboardRunHistoryItem {
 export interface CwdSuggestion {
   /** "dashboard" = this server's own cwd; "home" = user's home dir; "recent"
    *  = previously used for a run. */
-  kind: "dashboard" | "home" | "recent";
+  kind: "dashboard" | "home" | "recent" | "repo";
   path: string;
   label: string;
 }

client/src/lib/types.ts

@@ -2594,6 +2594,15 @@ export type LaneGitFacts =
       untracked: number;
       /** The files behind the counts, capped; the counts themselves stay exact. */
       files: LaneGitFile[];
+      /** Whether the repo has any remote configured at all. */
+      hasRemote: boolean;
+      /** `origin/<branch>`, or null when this branch has never been pushed. */
+      upstream: string | null;
+      /** Commits HEAD has that the upstream does not; null without an upstream
+       *  — not 0, which would claim "in sync" about a comparison never made. */
+      ahead: number | null;
+      /** Commits the upstream has that HEAD does not; null without an upstream. */
+      behind: number | null;
     }
   | { available: false };
 
@@ -2609,6 +2618,110 @@ export interface LaneGitFile {
   deleted: number | null;
 }
 
+/** One entry of `git worktree list` for a repo. */
+export interface LaneWorktree {
+  /** Absolute path of the worktree's directory. */
+  path: string;
+  /** The branch checked out there; absent for a detached worktree. */
+  branch?: string;
+  locked?: boolean;
+}
+
+/** Which comparison the Changes panel is showing. */
+export type LaneChangeRange = "work" | "branch" | "commit";
+
+/** One row of `GET /api/lanes/:id/git/log`. */
+export interface LaneCommit {
+  sha: string;
+  short: string;
+  subject: string;
+  author: string;
+  /** ISO 8601 author date. */
+  date: string;
+  /** `%D` decorations — `HEAD -> main`, `origin/main`, `tag: v1`… */
+  refs: string[];
+}
+
+/** `GET /api/lanes/:id/git/file` — one file's whole content at a revision. */
+export type LaneFileContent =
+  | {
+      available: true;
+      path: string;
+      rev: string;
+      binary: boolean;
+      truncated: boolean;
+      lines: string[];
+    }
+  | { available: false };
+
+/** One entry of `GET /api/lanes/:id/git/tree` — a folded directory or a file. */
+export interface LaneTreeEntry {
+  name: string;
+  /** Path relative to the repo root. */
+  path: string;
+  dir: boolean;
+}
+
+/** One row of a rendered diff — both gutters already resolved server-side. */
+export interface LaneDiffLine {
+  type: "ctx" | "add" | "del";
+  /** Line number on the left (before) side; null on an added line. */
+  oldLine: number | null;
+  /** Line number on the right (after) side; null on a removed line. */
+  newLine: number | null;
+  text: string;
+}
+
+/** One `@@` block of a file's diff. */
+export interface LaneDiffHunk {
+  header: string;
+  /** The function/section name git puts after the `@@`, when it found one. */
+  context: string;
+  oldStart: number;
+  newStart: number;
+  lines: LaneDiffLine[];
+}
+
+/** One changed file, as `GET /api/lanes/:id/git/changes` reports it. */
+export interface LaneChangeFile {
+  path: string;
+  /** Two-character porcelain code for the `work` range, `"M "`-style for `branch`. */
+  status: string;
+  untracked: boolean;
+  /** The file has changes in the index (`work` range only). */
+  staged?: boolean;
+  /** The file has changes only in the working tree (`work` range only). */
+  unstaged?: boolean;
+  /** The file is in a merge conflict (`work` range only). */
+  conflicted?: boolean;
+  added: number | null;
+  deleted: number | null;
+  binary: boolean;
+  /** Absent in overview mode (no `full`/`path`), `[]` for a binary file. */
+  hunks?: LaneDiffHunk[];
+  /** This file's patch was cut short by a size cap. */
+  truncated?: boolean;
+}
+
+/** `GET /api/lanes/:id/git/changes`. */
+export type LaneChanges =
+  | {
+      available: true;
+      range: LaneChangeRange;
+      /** The lane's base branch name, for `range: "branch"`. */
+      base: string | null;
+      /** The ref the base actually resolved to (`origin/main`, `main`, …). */
+      baseRef: string | null;
+      /** The commit being shown, for `range: "commit"`; its full sha. */
+      sha: string | null;
+      /** Lines of unchanged context each hunk carries. */
+      context: number;
+      files: LaneChangeFile[];
+      /** A cap bit: the file list or some patch was cut short. */
+      truncated: boolean;
+    }
+  | { available: false; range: LaneChangeRange; files: LaneChangeFile[] };
+
 /** Aggregate counts across all lanes. */
 export interface LaneCounts {
   total: number;

client/src/pages/Dashboard.tsx

@@ -169,7 +169,7 @@ function ChartTooltip({ x, y, children }: { x: number; y: number; children: Reac
   const nearRight = x > window.innerWidth - 200;
   return (
     <div
-      className="fixed z-50 px-2 py-1.5 text-xs bg-[#12121f] border border-[#2a2a4a] rounded shadow-xl text-fg-secondary pointer-events-none whitespace-nowrap"
+      className="fixed z-50 px-2 py-1.5 text-xs bg-surface-2 border border-border rounded shadow-xl text-fg-secondary pointer-events-none whitespace-nowrap"
       style={{
         left: nearRight ? x - 14 : x + 14,
         top: y - 10,

client/src/pages/Settings.tsx

@@ -369,7 +369,7 @@ function PricingInfoTooltip() {
         <div
           ref={popoverRef}
           role="tooltip"
-          className="fixed z-50 p-3 bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
+          className="fixed z-50 p-3 bg-surface-2 border border-border rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
           style={{ left: pos.left, top: pos.top, width: 320 }}
         >
           <p className="text-xs font-semibold text-fg-primary mb-2">{t("pricing.tooltip.title")}</p>

client/src/pages/Workflows.tsx

@@ -435,10 +435,10 @@ function ChartInfoPopover({ infoKey, title }: { infoKey: string; title: string }
         <div
           ref={popoverRef}
           role="tooltip"
-          className="fixed z-50 p-3.5 bg-[#12121f] border border-[#2a2a4a] rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
+          className="fixed z-50 p-3.5 bg-surface-2 border border-border rounded-lg shadow-2xl text-[11px] text-fg-secondary pointer-events-none"
           style={{ left: coords.left, top: coords.top, width: POPOVER_W }}
         >
-          <p className="text-xs font-semibold text-fg-primary mb-2.5 pb-2 border-b border-[#2a2a4a]">
+          <p className="text-xs font-semibold text-fg-primary mb-2.5 pb-2 border-b border-border">
             {title}
           </p>
 

client/src/pages/Workspace.tsx

@@ -43,7 +43,17 @@
 import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
 import { useSearchParams } from "react-router-dom";
 import { useTranslation } from "react-i18next";
-import { Plus, Square, Columns2, Grid2x2, Pencil, Layers } from "lucide-react";
+import {
+  Plus,
+  Square,
+  Columns2,
+  Grid2x2,
+  Pencil,
+  Layers,
+  PanelLeftClose,
+  ChevronsLeftRight,
+  PanelRightClose,
+} from "lucide-react";
 import { api } from "../lib/api";
 import type { CwdSuggestion, RunListResponse } from "../lib/api";
 import type { Lane, LaneFeature, ProofFeature, Session, WSMessage, LaneTool } from "../lib/types";
@@ -65,10 +75,36 @@ import LaneCard, {
 } from "../components/lanes/LaneCard";
 import LaneStripCard from "../components/lanes/LaneStripCard";
 import { AddLaneModal } from "../components/lanes/AddLaneModal";
+import { LaneChangesPanel } from "../components/lanes/LaneChangesPanel";
 import { DestructiveLaneModal } from "../components/lanes/DestructiveLaneModal";
 import { readSplitViewState, writeSplitViewState } from "../lib/splitViewStorage";
 import type { SplitViewState, SplitLayout } from "../lib/splitViewStorage";
 
+/** localStorage key for the Changes panel's open/closed state. */
+const CHANGES_OPEN_KEY = "agenthub.workspace.changesOpen";
+/** localStorage key for how wide the Changes panel is. */
+const CHANGES_SIZE_KEY = "agenthub.workspace.changesSize";
+
+/** The three widths the Changes panel cycles through, then closed. Reading a
+ *  diff and watching a console want opposite amounts of room, and which one is
+ *  "work" changes several times an hour — hence ONE control that steps
+ *  narrow → 50/50 → 70/30 → closed, rather than a width button beside a
+ *  collapse button that both live in the panel's tightest corner. */
+const CHANGES_SIZES = ["compact", "half", "wide"] as const;
+type ChangesSize = (typeof CHANGES_SIZES)[number];
+const CHANGES_WIDTH: Record<ChangesSize, string> = {
+  compact: "w-[28rem] xl:w-[34rem]",
+  half: "w-1/2",
+  wide: "w-[70%]",
+};
+/** The icon the one resize control shows AT each size: what the next click
+ *  gives you — an even split, a wider panel, then closed. */
+const CHANGES_NEXT_ICON: Record<ChangesSize, typeof Columns2> = {
+  compact: Columns2,
+  half: ChevronsLeftRight,
+  wide: PanelRightClose,
+};
+
 // ── Page ──────────────────────────────────────────────────────────────
 
 /** One pane, two side by side, four in a grid — the conventional icons for
@@ -206,6 +242,12 @@ export function Workspace() {
   const [selectedLaneId, setSelectedLaneId] = useState<number | null>(null);
   const [laneActionError, setLaneActionError] = useState<string | null>(null);
   const [addLaneOpen, setAddLaneOpen] = useState(false);
+  // Fields the Add-lane modal opens with when it was opened from a lane's git
+  // bar ("new lane here"): one provisioning path for every lane, prefilled.
+  const [addLanePrefill, setAddLanePrefill] = useState<{
+    sourceRepo?: string;
+    branch?: string;
+  } | null>(null);
   const [viewedFeatureSlug, setViewedFeatureSlug] = useState<string | null>(null);
   const [features, setFeatures] = useState<LaneFeature[]>([]);
   const [pipelineTemplates, setPipelineTemplates] = useState<
@@ -239,6 +281,44 @@ export function Workspace() {
   // single-pane view and collapsed in split view, but the toggle below can
   // override that in either mode — the user decides, not the layout.
   const [infoExpanded, setInfoExpanded] = useState(() => splitView.layout === 1);
+  // Whether the Changes panel is open. A viewer preference, so it lives in
+  // localStorage and never reaches the server — same rule as the lane strip's
+  // order (client/src/lib/laneOrderStorage.ts).
+  const [changesOpen, setChangesOpen] = useState(() => {
+    try {
+      return window.localStorage.getItem(CHANGES_OPEN_KEY) === "1";
+    } catch {
+      return false;
+    }
+  });
+  useEffect(() => {
+    try {
+      window.localStorage.setItem(CHANGES_OPEN_KEY, changesOpen ? "1" : "0");
+    } catch {
+      /* private mode / disabled storage: the panel just forgets between visits */
+    }
+  }, [changesOpen]);
+  const [changesSize, setChangesSize] = useState<ChangesSize>(() => {
+    try {
+      const saved = window.localStorage.getItem(CHANGES_SIZE_KEY) as ChangesSize | null;
+      return saved && CHANGES_SIZES.includes(saved) ? saved : "compact";
+    } catch {
+      return "compact";
+    }
+  });
+  useEffect(() => {
+    try {
+      window.localStorage.setItem(CHANGES_SIZE_KEY, changesSize);
+    } catch {
+      /* same as above: a forgotten width, not an error */
+    }
+  }, [changesSize]);
+  const nextChangesSize =
+    CHANGES_SIZES[(CHANGES_SIZES.indexOf(changesSize) + 1) % CHANGES_SIZES.length]!;
+  const changesNextLabel =
+    changesSize === CHANGES_SIZES[CHANGES_SIZES.length - 1]
+      ? tLanes("changes.collapse")
+      : tLanes("changes.resize", { size: tLanes(`changes.size.${nextChangesSize}`) });
   const showInfo = infoExpanded;
 
   const setLayout = useCallback((layout: SplitLayout) => {
@@ -579,15 +659,19 @@ export function Workspace() {
              which reads as a half-rendered row rather than a state. One banner
              instead — and a compact one on purpose: the run setup form below
              is what the user actually needs the height for. */
-          <div
+          <button
+            type="button"
             data-testid="lane-empty"
-            className="card flex shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4"
+            onClick={() => setAddLaneOpen(true)}
+            className="card flex w-full shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4 text-left transition-colors hover:border-accent/50 hover:bg-surface-2"
           >
             <span className="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-surface-4 text-fg-muted">
               <Layers className="h-5 w-5" />
             </span>
             <div className="min-w-0 flex-1">
-              <h2 className="text-sm font-medium text-fg-primary">{tLanes("empty.title")}</h2>
+              <span className="block text-sm font-medium text-fg-primary">
+                {tLanes("empty.title")}
+              </span>
               <p className="mt-0.5 text-xs text-fg-muted">
                 {tLanes("empty.body")}{" "}
                 <code className="rounded bg-surface-2 px-1.5 py-0.5 text-[11px] text-fg-secondary">
@@ -595,16 +679,11 @@ export function Workspace() {
                 </code>
               </p>
             </div>
-            <button
-              type="button"
-              data-testid="lane-tile-add"
-              onClick={() => setAddLaneOpen(true)}
-              className="btn-primary shrink-0"
-            >
+            <span className="flex shrink-0 items-center gap-1.5 text-xs font-medium text-accent">
               <Plus className="h-4 w-4" />
               {tLanes("add")}
-            </button>
-          </div>
+            </span>
+          </button>
         ) : (
           <div
             data-testid="lane-strip"
@@ -646,11 +725,17 @@ export function Workspace() {
             selection) unmounted the terminal and wiped a half-typed prompt.
             Same rule as RunConsole's own collapse — hide with CSS, never by
             unmounting. */}
-        <section
-          data-testid="lane-detail"
-          className={`flex min-h-0 min-w-0 flex-1 flex-col ${currentLane ? "card p-4" : ""}`}
-        >
-          {/* One header row, not two. The pipeline picker, the stage badges,
+        {/* Detail and the Changes panel share one row: the panel is a reading
+            surface for the same lane the console is driving, so it sits beside
+            it rather than under it. It collapses to a rail instead of
+            unmounting nothing — there is no live subscription inside it, so
+            unmounting is safe and keeps a closed panel from polling. */}
+        <div className="flex min-h-0 flex-1 gap-4">
+          <section
+            data-testid="lane-detail"
+            className={`flex min-h-0 min-w-0 flex-1 flex-col ${currentLane ? "card p-4" : ""}`}
+          >
+            {/* One header row, not two. The pipeline picker, the stage badges,
               the feature picker and the router select used to sit on a second
               row below this one; every one of them is a per-lane control that
               belongs beside the lane's own name, and stacking them cost a whole
@@ -658,245 +743,297 @@ export function Workspace() {
               down. The pipeline's NAME is no longer interpolated into
               `laneHeader` either — the picker right next to it already says it.
               They stay gated on `showInfo`, same as before the merge. */}
-          {currentLane && (
-            <div className="mb-3 flex flex-wrap items-center gap-2">
-              <span className="flex shrink-0 items-center gap-1.5 text-[11px] font-medium uppercase tracking-wide text-fg-secondary">
-                <span className={`h-2 w-2 rounded-full ${LIVENESS_DOT[currentLane.liveness]}`} />
-                {currentLane.liveness === "dead"
-                  ? tLanes("statusDead")
-                  : tLanes(`status.${currentLane.status}`, { defaultValue: currentLane.status })}
-              </span>
-              {/* The lane's name, and the one place it can be set. No "Lane 23 ·"
+            {currentLane && (
+              <div className="mb-3 flex flex-wrap items-center gap-2">
+                <span className="flex shrink-0 items-center gap-1.5 text-[11px] font-medium uppercase tracking-wide text-fg-secondary">
+                  <span className={`h-2 w-2 rounded-full ${LIVENESS_DOT[currentLane.liveness]}`} />
+                  {currentLane.liveness === "dead"
+                    ? tLanes("statusDead")
+                    : tLanes(`status.${currentLane.status}`, { defaultValue: currentLane.status })}
+                </span>
+                {/* The lane's name, and the one place it can be set. No "Lane 23 ·"
                   prefix any more: the id is on the strip tile, where the CLI's
                   `--lane` reader looks for it, and repeating it here only ate
                   the width the name needed. Submitting an empty name clears
                   `title`, which puts the cwd back in its place. */}
-              {renamingLaneId === currentLane.id ? (
-                <input
-                  data-testid="lane-rename-input"
-                  aria-label={tLanes("renameLabel")}
-                  autoFocus
-                  value={renameDraft}
-                  onChange={(e) => setRenameDraft(e.target.value)}
-                  // Blur CANCELS, it does not save — same convention as the
-                  // rename field in CcConfig. Committing here too would fire
-                  // the PATCH twice for one Enter: the commit unmounts the
-                  // focused input, and removing a focused element raises a
-                  // native blur before the refetch has moved `lanes`, so the
-                  // "unchanged title" guard would not catch the second call.
-                  onBlur={() => setRenamingLaneId(null)}
-                  onKeyDown={(e) => {
-                    if (e.key === "Enter") void commitRename(currentLane.id);
-                    if (e.key === "Escape") setRenamingLaneId(null);
-                  }}
-                  maxLength={200}
-                  className="min-w-0 flex-1 rounded border border-accent bg-surface-1 px-2 py-0.5 text-sm font-semibold text-fg-primary"
-                />
-              ) : (
-                <button
-                  type="button"
-                  data-testid="lane-rename"
-                  onClick={() => {
-                    setRenameDraft(currentLane.title || "");
-                    setRenamingLaneId(currentLane.id);
-                  }}
-                  title={`${currentLane.cwd}\n${tLanes("renameLabel")}`}
-                  className="group flex min-w-0 items-center gap-1 text-sm font-semibold text-fg-primary"
-                >
-                  <span className="min-w-0 truncate">{currentLane.title || currentLane.cwd}</span>
-                  <Pencil className="h-3 w-3 shrink-0 text-fg-muted opacity-0 transition-opacity group-hover:opacity-100" />
-                </button>
-              )}
-              <span className="shrink-0 tabular-nums text-xs text-fg-muted">
-                {since(currentLane.stage_seconds)}
-              </span>
-              {showInfo && (
-                <>
-                  <select
-                    data-testid="pipeline-picker"
-                    aria-label={tLanes("pipelinePicker.label")}
-                    className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs text-fg-secondary disabled:opacity-60"
-                    value={currentLane.pipeline}
-                    disabled={!!viewedFeature}
-                    title={
-                      viewedFeature
-                        ? tLanes("features.viewingArchived", { slug: viewedFeature.slug })
-                        : undefined
-                    }
-                    onChange={(e) => void handlePipelineChange(currentLane.id, e.target.value)}
+                {renamingLaneId === currentLane.id ? (
+                  <input
+                    data-testid="lane-rename-input"
+                    aria-label={tLanes("renameLabel")}
+                    autoFocus
+                    value={renameDraft}
+                    onChange={(e) => setRenameDraft(e.target.value)}
+                    // Blur CANCELS, it does not save — same convention as the
+                    // rename field in CcConfig. Committing here too would fire
+                    // the PATCH twice for one Enter: the commit unmounts the
+                    // focused input, and removing a focused element raises a
+                    // native blur before the refetch has moved `lanes`, so the
+                    // "unchanged title" guard would not catch the second call.
+                    onBlur={() => setRenamingLaneId(null)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter") void commitRename(currentLane.id);
+                      if (e.key === "Escape") setRenamingLaneId(null);
+                    }}
+                    maxLength={200}
+                    className="min-w-0 flex-1 rounded border border-accent bg-surface-1 px-2 py-0.5 text-sm font-semibold text-fg-primary"
+                  />
+                ) : (
+                  <button
+                    type="button"
+                    data-testid="lane-rename"
+                    onClick={() => {
+                      setRenameDraft(currentLane.title || "");
+                      setRenamingLaneId(currentLane.id);
+                    }}
+                    title={`${currentLane.cwd}\n${tLanes("renameLabel")}`}
+                    className="group flex min-w-0 items-center gap-1 text-sm font-semibold text-fg-primary"
                   >
-                    {(pipelineTemplates.length
-                      ? pipelineTemplates
-                      : [{ id: currentLane.pipeline, name: currentLane.pipeline_name, nodes: [] }]
-                    ).map((p) => (
-                      <option key={p.id} value={p.id}>
-                        {p.nodes.length ? `${p.name} (${p.nodes.length})` : p.name}
-                      </option>
-                    ))}
-                  </select>
-                  <LaneRouterRow lane={currentLane} />
-                  {/* `stage` defaults to the DB sentinel "idle" until the driving
-                      session ever calls `agenthub stage` — that string collides with
-                      `status`'s own "idle"/"running" vocabulary, so a lane that is
-                      actively running but has never declared a stage read as if it
-                      were sitting idle. Show a distinct label instead of the raw
-                      sentinel whenever it doesn't match any node this pipeline
-                      actually has. */}
-                  <span className="rounded bg-surface-2 px-2 py-0.5 text-xs text-fg-secondary">
-                    {currentLane.pipeline_nodes.some((n) => n.id === currentLane.stage)
-                      ? currentLane.stage
-                      : tLanes("stageUndeclared")}
-                  </span>
-                  {currentLane.detected_stage && (
-                    <span
-                      data-testid="detail-auto-stage"
-                      title={currentLane.detected_signal || undefined}
-                      className="rounded border border-dashed border-status-warning px-2 py-0.5 text-xs text-status-warning"
-                    >
-                      {tLanes("autoStage", { stage: currentLane.detected_stage })}
-                    </span>
-                  )}
-                  {features.length > 0 && (
+                    <span className="min-w-0 truncate">{currentLane.title || currentLane.cwd}</span>
+                    <Pencil className="h-3 w-3 shrink-0 text-fg-muted opacity-0 transition-opacity group-hover:opacity-100" />
+                  </button>
+                )}
+                <span className="shrink-0 tabular-nums text-xs text-fg-muted">
+                  {since(currentLane.stage_seconds)}
+                </span>
+                {showInfo && (
+                  <>
                     <select
-                      data-testid="feature-picker"
-                      className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs"
-                      value={viewedFeatureSlug ?? ""}
-                      onChange={(e) => setViewedFeatureSlug(e.target.value || null)}
+                      data-testid="pipeline-picker"
+                      aria-label={tLanes("pipelinePicker.label")}
+                      className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs text-fg-secondary disabled:opacity-60"
+                      value={currentLane.pipeline}
+                      disabled={!!viewedFeature}
+                      title={
+                        viewedFeature
+                          ? tLanes("features.viewingArchived", { slug: viewedFeature.slug })
+                          : undefined
+                      }
+                      onChange={(e) => void handlePipelineChange(currentLane.id, e.target.value)}
                     >
-                      <option value="">{tLanes("features.live")}</option>
-                      {features.map((f) => (
-                        <option key={f.slug} value={f.slug}>
-                          {f.slug}
-                          {f.archived_at ? ` (${tLanes("features.archived")})` : ""}
+                      {(pipelineTemplates.length
+                        ? pipelineTemplates
+                        : [{ id: currentLane.pipeline, name: currentLane.pipeline_name, nodes: [] }]
+                      ).map((p) => (
+                        <option key={p.id} value={p.id}>
+                          {p.nodes.length ? `${p.name} (${p.nodes.length})` : p.name}
                         </option>
                       ))}
                     </select>
-                  )}
-                </>
-              )}
-              <div className="ml-auto flex items-center gap-2">
-                {/* Per-lane actions (agents install, mcp sync, sync-base check)
+                    <LaneRouterRow lane={currentLane} />
+                    {/* No stage chip and no "auto: <stage>" chip here: the
+                        PipelineMap right below this header already draws both
+                        — the declared node as the current ring, the detected
+                        one as its amber badge — so the chips were a second,
+                        smaller copy of the same two facts. */}
+                    {features.length > 0 && (
+                      <select
+                        data-testid="feature-picker"
+                        className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs"
+                        value={viewedFeatureSlug ?? ""}
+                        onChange={(e) => setViewedFeatureSlug(e.target.value || null)}
+                      >
+                        <option value="">{tLanes("features.live")}</option>
+                        {features.map((f) => (
+                          <option key={f.slug} value={f.slug}>
+                            {f.slug}
+                            {f.archived_at ? ` (${tLanes("features.archived")})` : ""}
+                          </option>
+                        ))}
+                      </select>
+                    )}
+                  </>
+                )}
+                <div className="ml-auto flex items-center gap-2">
+                  {/* Per-lane actions (agents install, mcp sync, sync-base check)
                     belong beside the lane they act on, not in a page header. */}
-                <LaneToolsMenu lane={currentLane} />
-                <button
-                  type="button"
-                  data-testid="lane-detail-toggle"
-                  aria-expanded={infoExpanded}
-                  onClick={() => setInfoExpanded((v) => !v)}
-                  className="rounded border border-border-light px-2 py-1 text-xs text-fg-secondary transition-colors hover:text-fg-primary"
-                >
-                  {infoExpanded ? tLanes("laneDetail.hide") : tLanes("laneDetail.show")}
-                </button>
-                <SplitLayoutToggle splitView={splitView} setLayout={setLayout} />
-                {showInfo && (
+                  <LaneToolsMenu lane={currentLane} />
                   <button
                     type="button"
-                    data-testid="lane-action-remove"
-                    onClick={() => setRemoveConfirmOpen(true)}
-                    className="rounded px-2 py-0.5 text-xs text-status-danger transition-colors hover:bg-status-danger/15"
+                    data-testid="lane-detail-toggle"
+                    aria-expanded={infoExpanded}
+                    onClick={() => setInfoExpanded((v) => !v)}
+                    className="rounded border border-border-light px-2 py-1 text-xs text-fg-secondary transition-colors hover:text-fg-primary"
                   >
-                    {/* One label for both kinds: removal forgets the lane's row
-                        and never deletes a worktree, a branch or a database. */}
-                    {tLanes("action.forget")}
+                    {infoExpanded ? tLanes("laneDetail.hide") : tLanes("laneDetail.show")}
                   </button>
-                )}
-              </div>
-            </div>
-          )}
-          {currentLane && showInfo && (
-            <div className="max-h-[45vh] shrink-0 overflow-y-auto">
-              <div className="mb-3">
-                <LaneCard
-                  lane={currentLane}
-                  onAction={(a, b) => handleLaneAction(currentLane.id, a, b)}
-                  childWorktrees={lanes.filter(
-                    (l) => l.source_repo === currentLane.cwd && l.id !== currentLane.id
+                  <SplitLayoutToggle splitView={splitView} setLayout={setLayout} />
+                  {showInfo && (
+                    <button
+                      type="button"
+                      data-testid="lane-action-remove"
+                      onClick={() => setRemoveConfirmOpen(true)}
+                      className="rounded px-2 py-0.5 text-xs text-status-danger transition-colors hover:bg-status-danger/15"
+                    >
+                      {/* One label for both kinds: removal forgets the lane's row
+                        and never deletes a worktree, a branch or a database. */}
+                      {tLanes("action.forget")}
+                    </button>
                   )}
-                  onSelectLane={setSelectedLaneId}
-                />
+                </div>
               </div>
-              <div className="mb-3">
-                <PipelineMap
-                  nodes={viewedFeature ? viewedFeature.pipeline_nodes : currentLane.pipeline_nodes}
-                  detectedSignal={viewedFeature ? undefined : currentLane.detected_signal}
-                />
-                {viewedFeature && (
-                  <p data-testid="feature-viewer-banner" className="mb-2 text-xs text-fg-muted">
-                    {tLanes("features.viewingArchived", { slug: viewedFeature.slug })}
-                  </p>
-                )}
-              </div>
-              {proofFeature &&
-                (Object.keys(proofFeature.groups).length > 0 || proofFeature.ticket_report) && (
-                  <div data-testid="proof-gallery" className="mt-2">
-                    {proofFeature.ticket_report && (
-                      <a
-                        href={`/api/lanes/${currentLane.id}/proof/${proofFeature.ticket_report}`}
-                        target="_blank"
-                        rel="noreferrer"
-                        className="text-xs text-fg-muted"
-                      >
-                        {tLanes("proof.ticketReport")}
-                      </a>
+            )}
+            {currentLane && showInfo && (
+              <div className="max-h-[45vh] shrink-0 overflow-y-auto">
+                <div className="mb-3">
+                  <LaneCard
+                    lane={currentLane}
+                    onAction={(a, b) => handleLaneAction(currentLane.id, a, b)}
+                    childWorktrees={lanes.filter(
+                      (l) => l.source_repo === currentLane.cwd && l.id !== currentLane.id
                     )}
-                    {Object.entries(proofFeature.groups).map(([group, images]) => (
-                      <div key={group} className="mt-1">
-                        <span className="text-xs text-fg-muted">
-                          {group} · {images.length}
-                        </span>
-                        <div className="flex flex-wrap gap-1">
-                          {images.slice(0, 8).map((img) => (
-                            <img
-                              key={img}
-                              loading="lazy"
-                              className="h-16 w-16 rounded object-cover"
-                              src={api.lanes.proof.imageUrl(
-                                currentLane.id,
-                                proofFeature.slug,
-                                group,
-                                img
-                              )}
-                              alt={img}
-                            />
-                          ))}
-                          {images.length > 8 && (
-                            <span className="text-xs text-fg-muted">+{images.length - 8}</span>
-                          )}
+                    onSelectLane={setSelectedLaneId}
+                    onNewLaneFromRepo={(repo, branch) => {
+                      setAddLanePrefill({ sourceRepo: repo, branch });
+                      setAddLaneOpen(true);
+                    }}
+                  />
+                </div>
+                <div className="mb-3">
+                  <PipelineMap
+                    nodes={
+                      viewedFeature ? viewedFeature.pipeline_nodes : currentLane.pipeline_nodes
+                    }
+                    detectedSignal={viewedFeature ? undefined : currentLane.detected_signal}
+                  />
+                  {viewedFeature && (
+                    <p data-testid="feature-viewer-banner" className="mb-2 text-xs text-fg-muted">
+                      {tLanes("features.viewingArchived", { slug: viewedFeature.slug })}
+                    </p>
+                  )}
+                </div>
+                {proofFeature &&
+                  (Object.keys(proofFeature.groups).length > 0 || proofFeature.ticket_report) && (
+                    <div data-testid="proof-gallery" className="mt-2">
+                      {proofFeature.ticket_report && (
+                        <a
+                          href={`/api/lanes/${currentLane.id}/proof/${proofFeature.ticket_report}`}
+                          target="_blank"
+                          rel="noreferrer"
+                          className="text-xs text-fg-muted"
+                        >
+                          {tLanes("proof.ticketReport")}
+                        </a>
+                      )}
+                      {Object.entries(proofFeature.groups).map(([group, images]) => (
+                        <div key={group} className="mt-1">
+                          <span className="text-xs text-fg-muted">
+                            {group} · {images.length}
+                          </span>
+                          <div className="flex flex-wrap gap-1">
+                            {images.slice(0, 8).map((img) => (
+                              <img
+                                key={img}
+                                loading="lazy"
+                                className="h-16 w-16 rounded object-cover"
+                                src={api.lanes.proof.imageUrl(
+                                  currentLane.id,
+                                  proofFeature.slug,
+                                  group,
+                                  img
+                                )}
+                                alt={img}
+                              />
+                            ))}
+                            {images.length > 8 && (
+                              <span className="text-xs text-fg-muted">+{images.length - 8}</span>
+                            )}
+                          </div>
                         </div>
-                      </div>
-                    ))}
-                  </div>
-                )}
-            </div>
-          )}
-          <div
-            className={`flex min-h-0 flex-1 flex-col gap-2 ${
-              currentLane ? "border-t border-border pt-3" : ""
-            }`}
-          >
-            {/* `showToggle`: the lane header carries its own split toggle; with
+                      ))}
+                    </div>
+                  )}
+              </div>
+            )}
+            <div
+              className={`flex min-h-0 flex-1 flex-col gap-2 ${
+                currentLane ? "border-t border-border pt-3" : ""
+              }`}
+            >
+              {/* `showToggle`: the lane header carries its own split toggle; with
                 no lane there is no header, so the console shows one instead. */}
-            <ConsoleArea
-              lanes={lanes}
-              selectedLaneId={selectedLaneId}
-              splitView={splitView}
-              setLayout={setLayout}
-              setPaneLaneId={setPaneLaneId}
-              binaryStatus={binaryStatus}
-              cwdSuggestions={cwdSuggestions}
-              activeRuns={activeRuns}
-              externalSessions={externalSessions}
-              wsConnected={wsConnected}
-              defaultCwd={defaultCwd}
-              onHasActiveRunChange={setPaneHasActiveRun}
-              onLaneCreated={(lane) =>
-                setLanes((prev) => (prev.some((l) => l.id === lane.id) ? prev : [...prev, lane]))
-              }
-              onLaneIdChange={setSelectedLaneId}
-              showToggle={!currentLane}
-            />
-          </div>
-        </section>
+              <ConsoleArea
+                lanes={lanes}
+                selectedLaneId={selectedLaneId}
+                splitView={splitView}
+                setLayout={setLayout}
+                setPaneLaneId={setPaneLaneId}
+                binaryStatus={binaryStatus}
+                cwdSuggestions={cwdSuggestions}
+                activeRuns={activeRuns}
+                externalSessions={externalSessions}
+                wsConnected={wsConnected}
+                defaultCwd={defaultCwd}
+                onHasActiveRunChange={setPaneHasActiveRun}
+                onLaneCreated={(lane) =>
+                  setLanes((prev) => (prev.some((l) => l.id === lane.id) ? prev : [...prev, lane]))
+                }
+                onLaneIdChange={setSelectedLaneId}
+                showToggle={!currentLane}
+              />
+            </div>
+          </section>
+
+          {currentLane &&
+            (changesOpen ? (
+              <aside
+                id="lane-changes-panel"
+                data-testid="lane-changes-card"
+                className={`card flex shrink-0 flex-col p-3 ${CHANGES_WIDTH[changesSize]}`}
+              >
+                <div className="mb-2 flex items-center gap-2">
+                  <span className="text-[11px] font-medium uppercase tracking-wide text-fg-secondary">
+                    {tLanes("changes.title")}
+                  </span>
+                  <button
+                    type="button"
+                    data-testid="lane-changes-resize"
+                    onClick={() => {
+                      // Past the widest step the next state is "gone", which
+                      // is what the rail button reopens at `compact`.
+                      if (changesSize === CHANGES_SIZES[CHANGES_SIZES.length - 1]) {
+                        setChangesOpen(false);
+                        setChangesSize("compact");
+                      } else {
+                        setChangesSize(nextChangesSize);
+                      }
+                    }}
+                    // The control names the same region the rail button does,
+                    // so a screen reader reads one panel that is open or
+                    // closed rather than two unrelated buttons.
+                    aria-expanded
+                    aria-controls="lane-changes-panel"
+                    aria-label={changesNextLabel}
+                    title={changesNextLabel}
+                    className="ml-auto flex h-6 w-6 items-center justify-center rounded-md text-fg-muted transition-colors hover:bg-surface-4 hover:text-fg-primary"
+                  >
+                    {/* Icon-only, and it draws the width the click LANDS on,
+                        not the current one — the label the tooltip carries. */}
+                    {(() => {
+                      const Next = CHANGES_NEXT_ICON[changesSize];
+                      return <Next className="h-4 w-4" />;
+                    })()}
+                  </button>
+                </div>
+                <LaneChangesPanel laneId={currentLane.id} />
+              </aside>
+            ) : (
+              <button
+                type="button"
+                data-testid="lane-changes-expand"
+                onClick={() => setChangesOpen(true)}
+                aria-expanded={false}
+                aria-controls="lane-changes-panel"
+                aria-label={tLanes("changes.expand")}
+                title={tLanes("changes.expand")}
+                className="card flex w-9 shrink-0 flex-col items-center gap-2 py-3 text-fg-muted transition-colors hover:text-fg-primary"
+              >
+                <PanelLeftClose className="h-4 w-4" />
+                <span className="text-[10px] uppercase tracking-wide [writing-mode:vertical-rl]">
+                  {tLanes("changes.title")}
+                </span>
+              </button>
+            ))}
+        </div>
       </div>
 
       {currentLane && removeConfirmOpen && (
@@ -915,7 +1052,11 @@ export function Workspace() {
       <AddLaneModal
         open={addLaneOpen}
         cwdSuggestions={cwdSuggestions}
-        onClose={() => setAddLaneOpen(false)}
+        prefill={addLanePrefill}
+        onClose={() => {
+          setAddLaneOpen(false);
+          setAddLanePrefill(null);
+        }}
         onAdded={(lane) => {
           setLanes((prev) => (prev.some((l) => l.id === lane.id) ? prev : [...prev, lane]));
           setSelectedLaneId(lane.id);

client/src/pages/__tests__/Workspace.changesPanel.test.tsx

@@ -0,0 +1,182 @@
+/**
+ * @file Workspace.changesPanel.test.tsx
+ * @description The Changes panel is ONE control: it steps narrow → 50/50 →
+ * 70/30 → closed, and the rail reopens it narrow. The width survives a reload.
+ * All of it lives in localStorage and reaches no server — the same rule as the
+ * lane strip's order.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, act, cleanup, screen, fireEvent } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import i18n from "i18next";
+
+// Hoisted: `vi.mock`'s factory is lifted above the module body, so the
+// fixtures it reads have to be lifted with it.
+const { HOME, LANE_A, LANE_B } = vi.hoisted(() => {
+  const laneStub = (id: number, cwd: string) => ({
+    id,
+    title: `lane-${id}`,
+    cwd,
+    branch: null,
+    kind: "adopted",
+    source_repo: null,
+    pipeline: "default",
+    session_id: null,
+    run_id: null,
+    stage: "idle",
+    stage_since: null,
+    status: "idle",
+    gate_decision: null,
+    ci_status: null,
+    needs_action: null,
+    links: {},
+    stages: {},
+    notes: null,
+    pipeline_name: "Default",
+    pipeline_nodes: [],
+    progress: 0,
+    stage_seconds: null,
+    last_event_seconds: null,
+    liveness: "idle",
+    detected_stage: null,
+    detected_signal: null,
+    slot: null,
+    ports: {},
+    active_feature_id: null,
+  });
+  return {
+    HOME: { kind: "home", path: "/Users/tester", label: "Home" },
+    LANE_A: laneStub(1, "/workspace/alpha"),
+    LANE_B: laneStub(2, "/workspace/beta"),
+  };
+});
+
+vi.mock("../../lib/api", async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  const r = (value: unknown) => vi.fn().mockResolvedValue(value);
+  return {
+    ...actual,
+    api: {
+      run: {
+        list: r({ items: [] }),
+        history: r({ items: [] }),
+        binary: r({ found: true, path: "/usr/bin/claude" }),
+        cwds: r({ items: [HOME] }),
+        files: r({ items: [] }),
+        start: r({ id: "run-1", status: "running" }),
+        get: r({ id: "run-1", status: "running" }),
+      },
+      lanes: {
+        list: r({
+          lanes: [LANE_A, LANE_B],
+          counts: { total: 2, running: 0, needs_you: 0, dead: 0 },
+        }),
+        pipelines: r({ pipelines: [] }),
+        git: r({ available: false }),
+        runtime: r({ up: false, ports: {}, lastError: null }),
+        features: { list: r({ features: [] }), show: r({ feature: null }) },
+        proof: { list: r({ features: [] }), imageUrl: () => "" },
+      },
+      aiRouters: { list: r({ items: [] }) },
+      sessions: { list: r({ sessions: [], total: 0, limit: 50, offset: 0 }) },
+    },
+  };
+});
+
+vi.mock("../../lib/eventBus", () => ({
+  eventBus: {
+    subscribe: () => () => {},
+    publish: () => {},
+    onConnection: () => () => {},
+    connected: true,
+    setConnected: () => {},
+  },
+}));
+
+import { Workspace } from "../Workspace";
+
+class ObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+  takeRecords() {
+    return [];
+  }
+}
+globalThis.ResizeObserver =
+  globalThis.ResizeObserver || (ObserverStub as unknown as typeof ResizeObserver);
+
+async function settle() {
+  await act(async () => {
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 0));
+  });
+}
+
+beforeEach(() => {
+  i18n.changeLanguage("en");
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("Workspace — the Changes panel's width", () => {
+  beforeEach(() => window.localStorage.clear());
+
+  async function openPanel() {
+    render(
+      <MemoryRouter initialEntries={["/run"]}>
+        <Workspace />
+      </MemoryRouter>
+    );
+    await settle();
+    // Open/closed is itself remembered, so the second mount of a test comes up
+    // already open — clicking the rail then would close it.
+    const rail = screen.queryByTestId("lane-changes-expand");
+    if (rail) {
+      fireEvent.click(rail);
+      await settle();
+    }
+  }
+
+  it("steps narrow → 50/50 → 70/30 → closed on one control", async () => {
+    await openPanel();
+    const card = () => screen.getByTestId("lane-changes-card");
+    expect(card().className).toContain("w-[28rem]");
+
+    fireEvent.click(screen.getByTestId("lane-changes-resize"));
+    expect(card().className).toContain("w-1/2");
+
+    fireEvent.click(screen.getByTestId("lane-changes-resize"));
+    expect(card().className).toContain("w-[70%]");
+
+    // Past the widest step the panel closes — and reopens narrow, not back at
+    // 70/30, which is why closing resets the width.
+    fireEvent.click(screen.getByTestId("lane-changes-resize"));
+    await settle();
+    expect(screen.queryByTestId("lane-changes-card")).toBeNull();
+
+    fireEvent.click(screen.getByTestId("lane-changes-expand"));
+    await settle();
+    expect(card().className).toContain("w-[28rem]");
+  });
+
+  it("remembers the width across a reload, and never asks the server", async () => {
+    await openPanel();
+    fireEvent.click(screen.getByTestId("lane-changes-resize"));
+    expect(window.localStorage.getItem("agenthub.workspace.changesSize")).toBe("half");
+
+    cleanup();
+    await openPanel();
+    expect(screen.getByTestId("lane-changes-card").className).toContain("w-1/2");
+  });
+
+  it("keeps the rail as the only way back in", async () => {
+    await openPanel();
+    expect(screen.queryByTestId("lane-changes-collapse")).toBeNull();
+    expect(screen.getByTestId("lane-changes-card")).toBeInTheDocument();
+  });
+});

client/src/pages/__tests__/__snapshots__/screens.snapshot.test.tsx.snap

@@ -5099,9 +5099,10 @@ exports[`screen snapshots > Run 1`] = `
     <div
       class="flex min-h-0 flex-1 flex-col gap-4"
     >
-      <div
-        class="card flex shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4"
+      <button
+        class="card flex w-full shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4 text-left transition-colors hover:border-accent/50 hover:bg-surface-2"
         data-testid="lane-empty"
+        type="button"
       >
         <span
           class="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-surface-4 text-fg-muted"
@@ -5132,15 +5133,15 @@ exports[`screen snapshots > Run 1`] = `
         <div
           class="min-w-0 flex-1"
         >
-          <h2
-            class="text-sm font-medium text-fg-primary"
+          <span
+            class="block text-sm font-medium text-fg-primary"
           >
             No lanes yet
-          </h2>
+          </span>
           <p
             class="mt-0.5 text-xs text-fg-muted"
           >
-            A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Add one here, or from a terminal:
+            A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Click anywhere on this card to add one, or from a terminal:
              
             <code
               class="rounded bg-surface-2 px-1.5 py-0.5 text-[11px] text-fg-secondary"
@@ -5149,10 +5150,8 @@ exports[`screen snapshots > Run 1`] = `
             </code>
           </p>
         </div>
-        <button
-          class="btn-primary shrink-0"
-          data-testid="lane-tile-add"
-          type="button"
+        <span
+          class="flex shrink-0 items-center gap-1.5 text-xs font-medium text-accent"
         >
           <svg
             class="lucide lucide-plus h-4 w-4"
@@ -5174,229 +5173,319 @@ exports[`screen snapshots > Run 1`] = `
             />
           </svg>
           Add lane
-        </button>
-      </div>
-      <section
-        class="flex min-h-0 min-w-0 flex-1 flex-col "
-        data-testid="lane-detail"
+        </span>
+      </button>
+      <div
+        class="flex min-h-0 flex-1 gap-4"
       >
-        <div
-          class="flex min-h-0 flex-1 flex-col gap-2 "
+        <section
+          class="flex min-h-0 min-w-0 flex-1 flex-col "
+          data-testid="lane-detail"
         >
           <div
-            class="flex items-center gap-1.5"
+            class="flex min-h-0 flex-1 flex-col gap-2 "
           >
-            <button
-              aria-label="1 pane"
-              aria-pressed="true"
-              class="rounded border p-1.5 border-accent bg-accent/15 text-accent"
-              title="1 pane"
-              type="button"
-            >
-              <svg
-                class="lucide lucide-square h-3.5 w-3.5"
-                fill="none"
-                height="24"
-                stroke="currentColor"
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                stroke-width="2"
-                viewBox="0 0 24 24"
-                width="24"
-                xmlns="http://www.w3.org/2000/svg"
-              >
-                <rect
-                  height="18"
-                  rx="2"
-                  width="18"
-                  x="3"
-                  y="3"
-                />
-              </svg>
-            </button>
-            <button
-              aria-label="2 pane"
-              aria-pressed="false"
-              class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
-              title="2 pane"
-              type="button"
-            >
-              <svg
-                class="lucide lucide-columns2 h-3.5 w-3.5"
-                fill="none"
-                height="24"
-                stroke="currentColor"
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                stroke-width="2"
-                viewBox="0 0 24 24"
-                width="24"
-                xmlns="http://www.w3.org/2000/svg"
-              >
-                <rect
-                  height="18"
-                  rx="2"
-                  width="18"
-                  x="3"
-                  y="3"
-                />
-                <path
-                  d="M12 3v18"
-                />
-              </svg>
-            </button>
-            <button
-              aria-label="4 pane"
-              aria-pressed="false"
-              class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
-              title="4 pane"
-              type="button"
-            >
-              <svg
-                class="lucide lucide-grid2x2 h-3.5 w-3.5"
-                fill="none"
-                height="24"
-                stroke="currentColor"
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                stroke-width="2"
-                viewBox="0 0 24 24"
-                width="24"
-                xmlns="http://www.w3.org/2000/svg"
-              >
-                <path
-                  d="M12 3v18"
-                />
-                <path
-                  d="M3 12h18"
-                />
-                <rect
-                  height="18"
-                  rx="2"
-                  width="18"
-                  x="3"
-                  y="3"
-                />
-              </svg>
-            </button>
-          </div>
-          <div
-            class="flex min-h-0 flex-1 flex-col gap-5"
-            data-testid="console-body"
-          >
-            <header
-              class="flex items-center gap-2.5"
-            >
-              <div
-                class="w-7 h-7 rounded-lg bg-accent/15 flex items-center justify-center flex-shrink-0"
-              >
-                <svg
-                  class="lucide lucide-play w-3.5 h-3.5 text-accent"
-                  fill="none"
-                  height="24"
-                  stroke="currentColor"
-                  stroke-linecap="round"
-                  stroke-linejoin="round"
-                  stroke-width="2"
-                  viewBox="0 0 24 24"
-                  width="24"
-                  xmlns="http://www.w3.org/2000/svg"
-                >
-                  <polygon
-                    points="6 3 20 12 6 21 6 3"
-                  />
-                </svg>
-              </div>
-              <div
-                class="flex min-w-0 flex-1 items-center gap-2"
-              >
-                <div
-                  class="flex shrink-0 items-center gap-2"
-                >
-                  <h1
-                    class="text-base font-semibold text-fg-primary"
-                  >
-                    Run Claude
-                  </h1>
-                  <span
-                    class="flex items-center gap-1.5 text-[11px] text-status-success bg-status-success/10 border border-status-success/20 px-2 py-0.5 rounded-full"
-                  >
-                    <span
-                      class="w-1.5 h-1.5 rounded-full bg-status-success animate-pulse-dot"
-                    />
-                    Live
-                  </span>
-                </div>
-                <p
-                  class="hidden min-w-0 truncate text-[11px] text-fg-muted sm:block"
-                >
-                  Streamed output, multi-turn, same hooks and analytics as your terminal.
-                </p>
-              </div>
-              <button
-                class="inline-flex items-center gap-2 rounded-lg border px-3 py-1.5 text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed border-border bg-surface-2 text-fg-secondary hover:bg-surface-3"
-                disabled=""
-              >
-                <svg
-                  class="lucide lucide-list-ordered w-3.5 h-3.5"
-                  fill="none"
-                  height="24"
-                  stroke="currentColor"
-                  stroke-linecap="round"
-                  stroke-linejoin="round"
-                  stroke-width="2"
-                  viewBox="0 0 24 24"
-                  width="24"
-                  xmlns="http://www.w3.org/2000/svg"
-                >
-                  <path
-                    d="M10 12h11"
-                  />
-                  <path
-                    d="M10 18h11"
-                  />
-                  <path
-                    d="M10 6h11"
-                  />
-                  <path
-                    d="M4 10h2"
-                  />
-                  <path
-                    d="M4 6h1v4"
-                  />
-                  <path
-                    d="M6 18H4c0-1 2-2 2-3s-1-1.5-2-1"
-                  />
-                </svg>
-                Active runs
-              </button>
-            </header>
             <div
-              class="rounded-xl border border-border bg-surface-1"
+              class="flex items-center gap-1.5"
             >
-              <div
-                class="flex flex-wrap items-end gap-3 border-b border-border px-4 py-3"
+              <button
+                aria-label="1 pane"
+                aria-pressed="true"
+                class="rounded border p-1.5 border-accent bg-accent/15 text-accent"
+                title="1 pane"
+                type="button"
+              >
+                <svg
+                  class="lucide lucide-square h-3.5 w-3.5"
+                  fill="none"
+                  height="24"
+                  stroke="currentColor"
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="2"
+                  viewBox="0 0 24 24"
+                  width="24"
+                  xmlns="http://www.w3.org/2000/svg"
+                >
+                  <rect
+                    height="18"
+                    rx="2"
+                    width="18"
+                    x="3"
+                    y="3"
+                  />
+                </svg>
+              </button>
+              <button
+                aria-label="2 pane"
+                aria-pressed="false"
+                class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
+                title="2 pane"
+                type="button"
+              >
+                <svg
+                  class="lucide lucide-columns2 h-3.5 w-3.5"
+                  fill="none"
+                  height="24"
+                  stroke="currentColor"
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="2"
+                  viewBox="0 0 24 24"
+                  width="24"
+                  xmlns="http://www.w3.org/2000/svg"
+                >
+                  <rect
+                    height="18"
+                    rx="2"
+                    width="18"
+                    x="3"
+                    y="3"
+                  />
+                  <path
+                    d="M12 3v18"
+                  />
+                </svg>
+              </button>
+              <button
+                aria-label="4 pane"
+                aria-pressed="false"
+                class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
+                title="4 pane"
+                type="button"
+              >
+                <svg
+                  class="lucide lucide-grid2x2 h-3.5 w-3.5"
+                  fill="none"
+                  height="24"
+                  stroke="currentColor"
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="2"
+                  viewBox="0 0 24 24"
+                  width="24"
+                  xmlns="http://www.w3.org/2000/svg"
+                >
+                  <path
+                    d="M12 3v18"
+                  />
+                  <path
+                    d="M3 12h18"
+                  />
+                  <rect
+                    height="18"
+                    rx="2"
+                    width="18"
+                    x="3"
+                    y="3"
+                  />
+                </svg>
+              </button>
+            </div>
+            <div
+              class="flex min-h-0 flex-1 flex-col gap-5"
+              data-testid="console-body"
+            >
+              <header
+                class="flex items-center gap-2.5"
               >
                 <div
-                  class="grid min-w-0 flex-1 grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-4"
+                  class="w-7 h-7 rounded-lg bg-accent/15 flex items-center justify-center flex-shrink-0"
                 >
-                  <div>
-                    <label
-                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                  <svg
+                    class="lucide lucide-play w-3.5 h-3.5 text-accent"
+                    fill="none"
+                    height="24"
+                    stroke="currentColor"
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="2"
+                    viewBox="0 0 24 24"
+                    width="24"
+                    xmlns="http://www.w3.org/2000/svg"
+                  >
+                    <polygon
+                      points="6 3 20 12 6 21 6 3"
+                    />
+                  </svg>
+                </div>
+                <div
+                  class="flex min-w-0 flex-1 items-center gap-2"
+                >
+                  <div
+                    class="flex shrink-0 items-center gap-2"
+                  >
+                    <h1
+                      class="text-base font-semibold text-fg-primary"
                     >
-                      Working directory
-                    </label>
-                    <div
-                      title="Absolute path. Defaults to the dashboard's own cwd."
+                      Run Claude
+                    </h1>
+                    <span
+                      class="flex items-center gap-1.5 text-[11px] text-status-success bg-status-success/10 border border-status-success/20 px-2 py-0.5 rounded-full"
                     >
+                      <span
+                        class="w-1.5 h-1.5 rounded-full bg-status-success animate-pulse-dot"
+                      />
+                      Live
+                    </span>
+                  </div>
+                  <p
+                    class="hidden min-w-0 truncate text-[11px] text-fg-muted sm:block"
+                  >
+                    Streamed output, multi-turn, same hooks and analytics as your terminal.
+                  </p>
+                </div>
+                <button
+                  class="inline-flex items-center gap-2 rounded-lg border px-3 py-1.5 text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed border-border bg-surface-2 text-fg-secondary hover:bg-surface-3"
+                  disabled=""
+                >
+                  <svg
+                    class="lucide lucide-list-ordered w-3.5 h-3.5"
+                    fill="none"
+                    height="24"
+                    stroke="currentColor"
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="2"
+                    viewBox="0 0 24 24"
+                    width="24"
+                    xmlns="http://www.w3.org/2000/svg"
+                  >
+                    <path
+                      d="M10 12h11"
+                    />
+                    <path
+                      d="M10 18h11"
+                    />
+                    <path
+                      d="M10 6h11"
+                    />
+                    <path
+                      d="M4 10h2"
+                    />
+                    <path
+                      d="M4 6h1v4"
+                    />
+                    <path
+                      d="M6 18H4c0-1 2-2 2-3s-1-1.5-2-1"
+                    />
+                  </svg>
+                  Active runs
+                </button>
+              </header>
+              <div
+                class="rounded-xl border border-border bg-surface-1"
+              >
+                <div
+                  class="flex flex-wrap items-end gap-3 border-b border-border px-4 py-3"
+                >
+                  <div
+                    class="grid min-w-0 flex-1 grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-4"
+                  >
+                    <div>
+                      <label
+                        class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                      >
+                        Working directory
+                      </label>
                       <div
-                        class="relative"
+                        title="Absolute path. Defaults to the dashboard's own cwd."
                       >
                         <div
                           class="relative"
                         >
+                          <div
+                            class="relative"
+                          >
+                            <svg
+                              class="lucide lucide-folder-open absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-fg-muted pointer-events-none"
+                              fill="none"
+                              height="24"
+                              stroke="currentColor"
+                              stroke-linecap="round"
+                              stroke-linejoin="round"
+                              stroke-width="2"
+                              viewBox="0 0 24 24"
+                              width="24"
+                              xmlns="http://www.w3.org/2000/svg"
+                            >
+                              <path
+                                d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"
+                              />
+                            </svg>
+                            <input
+                              autocomplete="off"
+                              class="w-full bg-surface-2 border border-border rounded-md pl-7 pr-3 py-1.5 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50"
+                              placeholder="Type to search or paste an absolute path…"
+                              spellcheck="false"
+                              type="text"
+                              value=""
+                            />
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+                    <div>
+                      <label
+                        class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                      >
+                        Model
+                      </label>
+                      <div
+                        class="space-y-1.5"
+                      >
+                        <div
+                          class="relative"
+                        >
+                          <button
+                            class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
+                            type="button"
+                          >
+                            <span
+                              class="truncate"
+                            >
+                              Inherit from settings
+                            </span>
+                            <svg
+                              class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
+                              fill="none"
+                              height="24"
+                              stroke="currentColor"
+                              stroke-linecap="round"
+                              stroke-linejoin="round"
+                              stroke-width="2"
+                              viewBox="0 0 24 24"
+                              width="24"
+                              xmlns="http://www.w3.org/2000/svg"
+                            >
+                              <path
+                                d="m6 9 6 6 6-6"
+                              />
+                            </svg>
+                          </button>
+                        </div>
+                      </div>
+                    </div>
+                    <div>
+                      <label
+                        class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                      >
+                        Permission mode
+                      </label>
+                      <div
+                        class="relative"
+                      >
+                        <button
+                          class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
+                          type="button"
+                        >
+                          <span
+                            class="truncate"
+                          >
+                            auto (recommended - asks only for risky actions)
+                          </span>
                           <svg
-                            class="lucide lucide-folder-open absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-fg-muted pointer-events-none"
+                            class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
                             fill="none"
                             height="24"
                             stroke="currentColor"
@@ -5408,30 +5497,18 @@ exports[`screen snapshots > Run 1`] = `
                             xmlns="http://www.w3.org/2000/svg"
                           >
                             <path
-                              d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"
+                              d="m6 9 6 6 6-6"
                             />
                           </svg>
-                          <input
-                            autocomplete="off"
-                            class="w-full bg-surface-2 border border-border rounded-md pl-7 pr-3 py-1.5 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50"
-                            placeholder="Type to search or paste an absolute path…"
-                            spellcheck="false"
-                            type="text"
-                            value=""
-                          />
-                        </div>
+                        </button>
                       </div>
                     </div>
-                  </div>
-                  <div>
-                    <label
-                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                    >
-                      Model
-                    </label>
-                    <div
-                      class="space-y-1.5"
-                    >
+                    <div>
+                      <label
+                        class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                      >
+                        Thinking effort
+                      </label>
                       <div
                         class="relative"
                       >
@@ -5442,7 +5519,7 @@ exports[`screen snapshots > Run 1`] = `
                           <span
                             class="truncate"
                           >
-                            Inherit from settings
+                            Default (model decides)
                           </span>
                           <svg
                             class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
@@ -5464,155 +5541,81 @@ exports[`screen snapshots > Run 1`] = `
                       </div>
                     </div>
                   </div>
-                  <div>
-                    <label
-                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                  <div
+                    class="flex shrink-0 items-center rounded-md border border-border bg-surface-2 p-0.5 text-[11.5px]"
+                  >
+                    <button
+                      aria-pressed="true"
+                      class="rounded px-2 py-0.5 font-medium transition-colors bg-accent/20 text-accent"
+                      title="Start a fresh Claude Code session."
+                      type="button"
                     >
-                      Permission mode
-                    </label>
-                    <div
-                      class="relative"
+                      New session
+                    </button>
+                    <button
+                      aria-pressed="false"
+                      class="rounded px-2 py-0.5 font-medium transition-colors text-fg-secondary hover:text-fg-primary"
+                      title="Pick a session from your history and continue the conversation. Cwd is locked to the original."
+                      type="button"
                     >
-                      <button
-                        class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
-                        type="button"
-                      >
-                        <span
-                          class="truncate"
-                        >
-                          auto (recommended - asks only for risky actions)
-                        </span>
-                        <svg
-                          class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
-                          fill="none"
-                          height="24"
-                          stroke="currentColor"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                          stroke-width="2"
-                          viewBox="0 0 24 24"
-                          width="24"
-                          xmlns="http://www.w3.org/2000/svg"
-                        >
-                          <path
-                            d="m6 9 6 6 6-6"
-                          />
-                        </svg>
-                      </button>
-                    </div>
-                  </div>
-                  <div>
-                    <label
-                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                    >
-                      Thinking effort
-                    </label>
-                    <div
-                      class="relative"
-                    >
-                      <button
-                        class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
-                        type="button"
-                      >
-                        <span
-                          class="truncate"
-                        >
-                          Default (model decides)
-                        </span>
-                        <svg
-                          class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
-                          fill="none"
-                          height="24"
-                          stroke="currentColor"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                          stroke-width="2"
-                          viewBox="0 0 24 24"
-                          width="24"
-                          xmlns="http://www.w3.org/2000/svg"
-                        >
-                          <path
-                            d="m6 9 6 6 6-6"
-                          />
-                        </svg>
-                      </button>
-                    </div>
+                      Resume existing session
+                    </button>
                   </div>
                 </div>
                 <div
-                  class="flex shrink-0 items-center rounded-md border border-border bg-surface-2 p-0.5 text-[11.5px]"
+                  class="px-4 py-3 border-b border-border"
                 >
-                  <button
-                    aria-pressed="true"
-                    class="rounded px-2 py-0.5 font-medium transition-colors bg-accent/20 text-accent"
-                    title="Start a fresh Claude Code session."
-                    type="button"
+                  <label
+                    class="block text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5"
                   >
-                    New session
-                  </button>
-                  <button
-                    aria-pressed="false"
-                    class="rounded px-2 py-0.5 font-medium transition-colors text-fg-secondary hover:text-fg-primary"
-                    title="Pick a session from your history and continue the conversation. Cwd is locked to the original."
-                    type="button"
+                    Prompt
+                  </label>
+                  <textarea
+                    class="w-full bg-surface-2 border border-border rounded-md px-3 py-2 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50 resize-none"
+                    placeholder="Ask Claude anything…"
+                    rows="5"
+                  />
+                  <div
+                    class="mt-1 text-[10px] text-fg-muted"
                   >
-                    Resume existing session
+                    Cmd+Enter / Ctrl+Enter to send
+                     · / for slash commands · @ for file references
+                  </div>
+                </div>
+                <div
+                  class="border-t border-border px-4 py-3 flex items-center justify-between gap-3 flex-wrap"
+                >
+                  <div
+                    class="flex items-center gap-3 text-[11px] min-w-0"
+                  />
+                  <button
+                    class="inline-flex items-center gap-2 rounded-lg border border-accent/40 bg-accent/15 hover:bg-accent/25 text-accent px-4 py-1.5 text-sm font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+                    disabled=""
+                  >
+                    <svg
+                      class="lucide lucide-play w-3.5 h-3.5"
+                      fill="none"
+                      height="24"
+                      stroke="currentColor"
+                      stroke-linecap="round"
+                      stroke-linejoin="round"
+                      stroke-width="2"
+                      viewBox="0 0 24 24"
+                      width="24"
+                      xmlns="http://www.w3.org/2000/svg"
+                    >
+                      <polygon
+                        points="6 3 20 12 6 21 6 3"
+                      />
+                    </svg>
+                    Run
                   </button>
                 </div>
               </div>
-              <div
-                class="px-4 py-3 border-b border-border"
-              >
-                <label
-                  class="block text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5"
-                >
-                  Prompt
-                </label>
-                <textarea
-                  class="w-full bg-surface-2 border border-border rounded-md px-3 py-2 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50 resize-none"
-                  placeholder="Ask Claude anything…"
-                  rows="5"
-                />
-                <div
-                  class="mt-1 text-[10px] text-fg-muted"
-                >
-                  Cmd+Enter / Ctrl+Enter to send
-                   · / for slash commands · @ for file references
-                </div>
-              </div>
-              <div
-                class="border-t border-border px-4 py-3 flex items-center justify-between gap-3 flex-wrap"
-              >
-                <div
-                  class="flex items-center gap-3 text-[11px] min-w-0"
-                />
-                <button
-                  class="inline-flex items-center gap-2 rounded-lg border border-accent/40 bg-accent/15 hover:bg-accent/25 text-accent px-4 py-1.5 text-sm font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-                  disabled=""
-                >
-                  <svg
-                    class="lucide lucide-play w-3.5 h-3.5"
-                    fill="none"
-                    height="24"
-                    stroke="currentColor"
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    stroke-width="2"
-                    viewBox="0 0 24 24"
-                    width="24"
-                    xmlns="http://www.w3.org/2000/svg"
-                  >
-                    <polygon
-                      points="6 3 20 12 6 21 6 3"
-                    />
-                  </svg>
-                  Run
-                </button>
-              </div>
             </div>
           </div>
-        </div>
-      </section>
+        </section>
+      </div>
     </div>
   </div>
 </div>
@@ -9614,7 +9617,7 @@ exports[`screen snapshots > Settings 1`] = `
             <p
               class="text-[10px] text-status-warning/90 mt-1"
             >
-              UI build v1.7.0 (rebuild client to match)
+              UI build v1.8.1 (rebuild client to match)
             </p>
           </div>
           <div