pi-repoprompt-mcp 0.4.0 → 0.5.0

package/README.md

@@ -1,8 +1,8 @@
 # RepoPrompt MCP for Pi (`pi-repoprompt-mcp`)
 
-This package provides a single tool (`rp`) that exposes the RepoPrompt MCP tools to Pi, includes branch-safe window and tab binding (automatically detecting the right window by `cwd`, provisioning a safe tab, persisting both across sessions and session tree nodes, and letting you pick windows and tabs interactively) and batches of read files (automatically selected as context in the RepoPrompt desktop app), renders RepoPrompt tool outputs (syntax + diff highlighting), and applies guardrails for destructive operations.
+This extension provides a single tool (`rp`) that exposes RepoPrompt MCP tools to Pi, includes branch-safe window and tab binding (auto-detect and bind to window by `cwd`, auto-bind to safe tab, persist and restore across sessions and session tree nodes, and interactive selection of windows and tabs) and batches of read files (automatically selected as context in the RepoPrompt desktop app), renders RepoPrompt tool outputs (syntax + diff highlighting), and applies guardrails for destructive operations.
 
-The package's window- and tab-related management features allow a workflow where new Pi sessions automatically attach to the required workspace and tab without clobbering your, or other agents', parallel usage of RepoPrompt.  Because it recovers the window, tab, and auto-selected read-files context when you rewind via `/tree` or restore a session, all the context the agent has built up (and automatically selected in the RepoPrompt app) by reading files and slices up to that point always remains available in the app for RP Chat (see `/rp oracle` below) or external "oracle" (e.g. GPT-x Pro) use cases.  **Note: this recovery currently requires the original workspace (but not necessarily its original tabs) to be open, not just any workspace containing the same required root(s).**
+The extension's window- and tab-related management features allow a workflow where new Pi sessions automatically attach to the required workspace and tab without clobbering your, or other agents', parallel usage of RepoPrompt.  Because it recovers the window, tab, and auto-selected read-files context when you rewind via `/tree` or restore a session, all the context the agent has built up (and automatically selected in the RepoPrompt app) by reading files and slices up to that point always remains available in the app for RP Chat (see `/rp oracle` below) or external "oracle" (e.g. GPT-x Pro) use cases.  Recovery is based on the required root(s) of the saved selection state, so it can reattach to any open workspace that already contains those roots rather than requiring the original workspace name; if multiple open workspaces satisfy that requirement and `cwd` does not disambiguate them, then you should re-bind with `/rp bind`.
 
 ## Installation
 
@@ -37,19 +37,34 @@ Add to `~/.pi/agent/settings.json` (or replace an existing unfiltered `git:githu
 - Auto-binds to the RepoPrompt window that matches `process.cwd()` (by workspace roots, resolving symlinks to their real paths before matching)
   - If multiple windows match, you're prompted to pick one
   - Window binding is (optionally) persisted across session reloads and session tree nodes
-- If a bound window has a completely blank tab, the package binds to that tab; if the tab is dirty, then it provisions a new tab and binds to that
+- If a bound window has an existing tab with zero selected files and no chats, the extension binds to that tab; otherwise it provisions a new tab and binds to that
 - Deterministically reconciles the session tree node's bound tab, and can restore the tab already associated with that node or provision a new safe tab when needed
 - User-driven binding via `/rp bind` (windows) or `/rp tab` (tabs); agents can use `rp({ bind: ... })`
 - In addition to window bindings, tab bindings and auto-selected read-files context is stored and automatically recovered across node rewinds via `/tree`, different sessions (e.g., created via `/fork`), and resumed sessions
 
-Forked sessions inherit the parent session-plus-node's window, tab, and auto-selected context snapshot at the fork point (unless you rewind in the forked session and switch window/tab/etc.), then can diverge independently as later reads or manual tab switches are performed in the child session.  Binding is non-invasive, in that it doesn't change RepoPrompt's globally active window, and automatic tab provisioning uses background tabs (`focus=false`) without stealing UI focus.  This is to prevent interference when multiple agents (or your manual usage of RepoPrompt in parallel to a Pi session) are using this package and need to target different windows or tabs simultaneously.
+Forked sessions inherit the parent session-plus-node's window, tab, and auto-selected context snapshot at the fork point (unless you rewind in the forked session and switch window/tab/etc.), then can diverge independently as later reads or manual tab switches are performed in the child session.  Binding is non-invasive, in that it doesn't change RepoPrompt's globally active window, and automatic tab provisioning uses background tabs (`focus=false`) without stealing UI focus.  This is to prevent interference when multiple agents (or your manual usage of RepoPrompt in parallel to a Pi session) are using this extension and need to target different windows or tabs simultaneously.
 
 ### Output rendering
 
-- Syntax highlighting for read files' code blocks and for codemaps
-- Diff highlighting for diff blocks (`delta` when installed, honoring the user's global git/delta color config, graceful fallback otherwise)
+- Syntax highlighting for code blocks and codemaps in `read_file`, and for code blocks in outputs of `apply_edits`, `file_actions create/delete`, and `git`
+- Common non-mutating RepoPrompt actions (`read_file`, `file_search`, `get_file_tree`, `get_code_structure`, `workspace_context`, routing helpers like `manage_workspaces`, and control/discovery actions like `windows`/`bind`/`status`/`search`/`describe`) get concise request-driven call/result summaries in collapsed mode.  The call line carries intent while the result line carries outcome, so the transcript stays compact without echoing the same label twice.  These summaries are derived from the arguments Pi sent, not by parsing RepoPrompt's prose output, and unknown tools fall back to normal collapsed rendering
+
+<p align="center">
+  <img width="270" height="936" alt="Image" src="https://github.com/user-attachments/assets/142ca6c2-c1cf-4f0b-b41b-3d52d623c78c" />
+</p>
+
+- RepoPrompt `apply_edits` calls are forwarded with `verbose: true` by default (unless `raw: true`), while the returned diff is normalized into `details.diff` and presented to the agent as a terse summary.  The same is done for `file_actions create/delete` outputs, so you see all edited/created/deleted LOC with rich rendering but the extension prevents the context window from getting bloated by round-tripping tool I/O tokens
+- Adaptive diff rendering for RepoPrompt `git` and `apply_edits` outputs by default (`diffViewMode: "auto"` picks split, unified, compact, or summary at render time based on pane width).  This uses the active Pi theme's `toolDiffAdded`, `toolDiffRemoved`, and `toolDiffContext` colors (typically mapped to chosen hues for green and red), and its visual design and rendering logic are indebted to [MasuRii/pi-tool-display](https://github.com/MasuRii/pi-tool-display).  Two different examples at different pane widths:
+
+<p align="center">
+  <img width="1027" height="256" alt="horizontal" src="https://github.com/user-attachments/assets/31943d5b-475c-4254-813b-18bf9bd79d60" />
+</p>
+<p align="center">
+  <img width="629" height="302" alt="vertical" src="https://github.com/user-attachments/assets/fe4fc253-6bda-49e3-a37e-918244eb9e05" />
+</p>
+
+- Generic fenced diff blocks, and adaptive-diff parse failures, fall back to a simpler diff renderer, which uses `delta` if installed or otherwise the built-in highlighter
 - Markdown-aware styling for headings and lists
-- Collapsed output by default (expand using Pi's standard UI controls)
 
 ### Safety checks
 
@@ -60,31 +75,36 @@ Forked sessions inherit the parent session-plus-node's window, tab, and auto-sel
 ## Requirements
 
 - RepoPrompt MCP server configured and reachable (stdio transport)
-  - If the server is not configured/auto-detected, the package will still load, but `rp(...)` will error until you configure it
+  - If the server is not configured/auto-detected, the extension will still load, but `rp(...)` will error until you configure it
 - `rp-cli` available in `PATH` is recommended (used as a fallback for window discovery)
 
 ### Compatibility notes
 
-This package tries to be tolerant of **tool name prefixing** (e.g. `RepoPrompt_list_windows` vs `list_windows`), but it is still dependent on a small set of capabilities and their semantics remaining reasonably stable across RepoPrompt versions:
+This extension tries to be tolerant of **tool name prefixing** (e.g. `RepoPrompt_list_windows` vs `list_windows`), but it is still dependent on a small set of capabilities and their semantics remaining reasonably stable across RepoPrompt versions:
 
 - **Window discovery**: `list_windows`
-  - If `list_windows` is not exposed by the MCP server, the package falls back to `rp-cli -e 'windows'`
+  - If `list_windows` is not exposed by the MCP server, the extension falls back to `rp-cli -e 'windows'`
   - If neither is available, window listing/binding features will be limited
 - **Workspace root discovery (auto-bind by cwd)**: `get_file_tree` with `{ type: "roots" }` (scoped by `_windowID`)
   - If unavailable (or if parameters/semantics change), auto-binding may be disabled or less accurate
 - Selection summary: `manage_selection` with `{ op: "get", view: "files" }` and `{ op: "get", view: "summary" }`
   - If these are unavailable (or if parameters/semantics change), the status output may omit file/token counts
 
-If RepoPrompt renames/removes these tools or changes their required parameters/output formats, this package may need updates
+If RepoPrompt renames/removes these tools or changes their required parameters/output formats, this extension may need updates
 
 ## Usage
 
 ### Commands
 
 - `/rp status` — show status (connection + binding), including the currently bound tab name and a label like `[bound, in-focus]` or `[bound, out-of-focus]`, plus current selected file counts and estimated token counts
+
+<p align="center">
+  <img width="210" alt="status" src="https://github.com/user-attachments/assets/bd59af9e-7df1-4572-8baf-edb6f8f7a0df" />
+</p>
+
 - `/rp windows` — list available RepoPrompt windows
 - `/rp bind` — interactive workflow for choosing the RepoPrompt window
-- `/rp bind <id> [tab]` — direct option if you already know the target window id (and optionally an exact tab name or tab id); when `[tab]` is omitted, the package restores the branch's tab for that window or provisions a fresh background tab once
+- `/rp bind <id> [tab]` — direct option if you already know the target window id (and optionally an exact tab name or tab id); when `[tab]` is omitted, the extension restores the branch's tab for that window or provisions a fresh background tab once
 - `/rp tab` — interactive tab picker for the current bound window, with `Create new tab` as the first option followed by existing tab names
 - `/rp tab new` — create and bind a fresh tab on the current bound window
 - `/rp tab <name-or-id>` — bind an existing tab on the current bound window by name or id
@@ -150,11 +170,13 @@ Create `~/.pi/agent/extensions/repoprompt-mcp.json`:
   "oracleDefaultMode": "chat",
 
   "collapsedMaxLines": 3,
+  "diffViewMode": "auto",
+  "diffSplitMinWidth": 120,
   "suppressHostDisconnectedLog": true
 }
 ```
 
-`collapsedMaxLines` controls how many lines of RepoPrompt tool output Pi shows before the result is expanded. This applies to the collapsed preview for all `rp(...)` calls, including commands like window listings and file reads.  **Recommended setting for maximally compressed** but still informative output: `3`.
+`collapsedMaxLines` controls how many rendered lines of RepoPrompt tool output Pi shows before the result is expanded for the generic fallback path.  In addition, the extension now emits hand-authored one-line or two-line collapsed summaries for common non-mutating actions like `read_file`, `file_search`, `get_file_tree`, `get_code_structure`, `workspace_context`, `windows`, `bind`, and `status`; these are derived from Pi's own request metadata rather than RepoPrompt's returned prose.  Unknown or unsupported tools still fall back to the normal `collapsedMaxLines` behavior.  LOC-changing operations are the other exception: verbose RepoPrompt `apply_edits` and rendered `file_actions create/delete` results ignore `collapsedMaxLines` once normalized into `details.diff`, so the full rendered code changes remain visible.
 
 Options:
 
@@ -168,14 +190,16 @@ Options:
 | `confirmDeletes` | `true` | Block delete operations unless `allowDelete: true` |
 | `confirmEdits` | `false` | Block edit-like operations unless `confirmEdits: true` |
 | `readcacheReadFile` | `false` | Enable [pi-readcache](https://github.com/Gurpartap/pi-readcache)-like caching for RepoPrompt `read_file` calls (returns unchanged markers/diffs on repeat reads to save on tokens and prevent context bloat) |
-| `autoSelectReadSlices` | `true` | Automatically track `read_file` calls by adding slices/full-file selection via `manage_selection`, so `chat_send` (or a manually created chat in the RP app) uses everything the agent has read as context; these file/slice selections are **branch-safe** across `/tree` rewinds and `/fork`ed session branches via package-owned snapshot replay |
+| `autoSelectReadSlices` | `true` | Automatically track `read_file` calls by adding slices/full-file selection via `manage_selection`, so `chat_send` (or a manually created chat in the RP app) uses everything the agent has read as context; these file/slice selections are **branch-safe** across `/tree` rewinds and `/fork`ed session branches via extension-owned snapshot replay |
 | `oracleDefaultMode` | `"chat"` | Default mode for `/rp oracle` when `--mode` is omitted (`chat`, `plan`, `edit`, or `review`) |
-| `collapsedMaxLines` | `15` | Lines shown in collapsed view |
+| `collapsedMaxLines` | `3` | Lines shown in collapsed view |
+| `diffViewMode` | `"auto"` | Diff layout for RepoPrompt `git` / `apply_edits` fenced diff output (`auto`, `split`, `unified`) |
+| `diffSplitMinWidth` | `120` | Minimum render width before `diffViewMode: "auto"` uses split diff layout |
 | `suppressHostDisconnectedLog` | `true` | Filter noisy stderr from macOS `repoprompt-mcp` (disconnect/retry bootstrap logs) |
 
-Automatic tab restoration and provisioning is driven by `autoBindOnStart` and `persistBinding`; there is no separate tab-only configuration surface.
+Automatic tab restoration and provisioning is driven by `autoBindOnStart` and `persistBinding`; there is no separate tab-only configuration surface. Adaptive diff layout applies only to RepoPrompt `git` and `apply_edits` outputs that arrive as fenced `diff` blocks; other rendered output stays on the existing text-based path.
 
-Note: when `readcacheReadFile` is enabled, the package may persist UTF-8 file snapshots to an on-disk content-addressed store under
+Note: when `readcacheReadFile` is enabled, the extension may persist UTF-8 file snapshots to an on-disk content-addressed store under
 `<repo-root>/.pi/readcache/objects` to compute diffs/unchanged markers across calls. Common secret filenames (e.g. `.env*`, `*.pem`) are excluded,
 but this is best-effort
 
@@ -193,7 +217,7 @@ but this is best-effort
 - Run `/rp reconnect`
 
 ### Pi becomes unresponsive after closing/restarting RepoPrompt
-If the RepoPrompt MCP server stops responding (for example, if the RepoPrompt app is closed while Pi stays open), tool calls may time out. When that happens, the package will drop the connection and you can recover with `/rp reconnect`.
+If the RepoPrompt MCP server stops responding (for example, if the RepoPrompt app is closed while Pi stays open), tool calls may time out. When that happens, the extension will drop the connection and you can recover with `/rp reconnect`.
 
 ### "No matching window found"
 - Your `cwd` may not match any RepoPrompt workspace root
@@ -201,7 +225,7 @@ If the RepoPrompt MCP server stops responding (for example, if the RepoPrompt ap
 - Use `/rp bind` to pick one
 
 ### Window listing doesn't work
-- If the MCP server does not expose a `list_windows` tool, this package uses `rp-cli -e 'windows'`
+- If the MCP server does not expose a `list_windows` tool, this extension uses `rp-cli -e 'windows'`
 - Make sure `rp-cli` is installed and on your `PATH`
 - If RepoPrompt is in single-window mode, `rp-cli -e 'windows'` may report single-window mode
 

package/extensions/repoprompt-mcp/src/binding.ts

@@ -3,6 +3,7 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import { realpathSync } from "node:fs";
+import { access } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -523,6 +524,141 @@ function canonicalizePathForMatching(inputPath: string): string {
   }
 }
 
+async function pathExists(absolutePath: string): Promise<boolean> {
+  try {
+    await access(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseSelectionRootPath(rawPath: string): { rootHint: string; relPath: string } | null {
+  const colonIdx = rawPath.indexOf(":");
+  if (colonIdx > 0) {
+    const rootHint = rawPath.slice(0, colonIdx).trim();
+    const relPath = rawPath.slice(colonIdx + 1).replace(/^\/+/, "");
+    if (rootHint && relPath) {
+      return { rootHint, relPath };
+    }
+  }
+
+  const parts = rawPath.split(/[\\/]+/).filter(Boolean);
+  if (parts.length >= 2) {
+    return {
+      rootHint: parts[0],
+      relPath: parts.slice(1).join("/"),
+    };
+  }
+
+  return null;
+}
+
+async function windowContainsSelectionPath(window: RpWindow, selectionPath: string, cwd: string): Promise<boolean> {
+  const normalizedPath = selectionPath.trim();
+  if (!normalizedPath) {
+    return false;
+  }
+
+  if (path.isAbsolute(normalizedPath)) {
+    return window.roots.some((root) => isPathWithinRoot(normalizedPath, root));
+  }
+
+  const rootScoped = parseSelectionRootPath(normalizedPath);
+  if (rootScoped) {
+    const matchingRoots = window.roots.filter((root) => path.basename(root) === rootScoped.rootHint);
+    for (const root of matchingRoots) {
+      if (await pathExists(path.join(root, rootScoped.relPath))) {
+        return true;
+      }
+    }
+  }
+
+  const cwdRelativePath = path.resolve(cwd, normalizedPath);
+  if (await pathExists(cwdRelativePath)) {
+    return window.roots.some((root) => isPathWithinRoot(cwdRelativePath, root));
+  }
+
+  for (const root of window.roots) {
+    if (await pathExists(path.join(root, normalizedPath))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export interface FindRecoveryWindowBySelectionPathsResult {
+  window: RpWindow | null;
+  ambiguous: boolean;
+  matches: RpWindow[];
+}
+
+export async function findRecoveryWindowBySelectionPaths(
+  windows: RpWindow[],
+  selectionPaths: string[],
+  cwd: string
+): Promise<FindRecoveryWindowBySelectionPathsResult> {
+  const requiredPaths = [...new Set(selectionPaths.map((item) => item.trim()).filter(Boolean))];
+  if (requiredPaths.length === 0) {
+    return {
+      window: null,
+      ambiguous: false,
+      matches: [],
+    };
+  }
+
+  await Promise.all(
+    windows.map(async (window) => {
+      if (window.roots.length === 0) {
+        window.roots = await fetchWindowRoots(window.id);
+      }
+    })
+  );
+
+  const matches: RpWindow[] = [];
+  for (const window of windows) {
+    const compatibility = await Promise.all(
+      requiredPaths.map((selectionPath) => windowContainsSelectionPath(window, selectionPath, cwd))
+    );
+
+    if (compatibility.every(Boolean)) {
+      matches.push(window);
+    }
+  }
+
+  if (matches.length === 0) {
+    return {
+      window: null,
+      ambiguous: false,
+      matches: [],
+    };
+  }
+
+  if (matches.length === 1) {
+    return {
+      window: matches[0],
+      ambiguous: false,
+      matches,
+    };
+  }
+
+  const cwdMatch = findMatchingWindow(matches, cwd);
+  if (cwdMatch.window && !cwdMatch.ambiguous) {
+    return {
+      window: cwdMatch.window,
+      ambiguous: false,
+      matches,
+    };
+  }
+
+  return {
+    window: null,
+    ambiguous: true,
+    matches,
+  };
+}
+
 /**
  * Get workspace roots for a specific window
  */
@@ -598,7 +734,7 @@ function stripTrailingTabStateAnnotations(name: string): string {
   }
 }
 
-function parseFileCountMaybe(value: unknown): number | undefined {
+function parseCountMaybe(value: unknown): number | undefined {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
   }
@@ -634,7 +770,7 @@ function parseTabFromJson(raw: unknown): RpTab | null {
     name: name || idRaw.trim(),
     isActive: parseBooleanMaybe(obj.isActive ?? obj.active ?? obj.selected ?? obj.is_active ?? obj.inFocus ?? obj.in_focus),
     isBound: parseBooleanMaybe(obj.isBound ?? obj.bound ?? obj.pinned ?? obj.is_bound),
-    selectedFileCount: parseFileCountMaybe(
+    selectedFileCount: parseCountMaybe(
       obj.selectedFileCount ?? obj.selected_file_count ?? obj.fileCount ?? obj.file_count
     ),
   };
@@ -751,7 +887,7 @@ export function parseTabList(text: string): RpTab[] {
 
     const fileCountMatch = line.match(/•\s*([\d,]+)\s+files\b/i);
     if (fileCountMatch?.[1]) {
-      lastTab.selectedFileCount = parseFileCountMaybe(fileCountMatch[1]);
+      lastTab.selectedFileCount = parseCountMaybe(fileCountMatch[1]);
     }
   }
 
@@ -763,6 +899,87 @@ function parseTabsFromJson(value: unknown): RpTab[] | null {
   return tabs.length > 0 ? dedupeTabs(tabs) : null;
 }
 
+function parseChatCountFromJson(value: unknown): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+
+  if (typeof value !== "object") {
+    return undefined;
+  }
+
+  const obj = value as Record<string, unknown>;
+  const directCount = parseCountMaybe(
+    obj.count ?? obj.chatCount ?? obj.chat_count ?? obj.total ?? obj.totalCount ?? obj.total_count
+  );
+  if (directCount !== undefined) {
+    return directCount;
+  }
+
+  for (const key of ["chats", "sessions", "items", "results"]) {
+    const candidate = obj[key];
+    if (Array.isArray(candidate)) {
+      return candidate.length;
+    }
+  }
+
+  return undefined;
+}
+
+function parseChatCountFromText(text: string): number | undefined {
+  const countMatch = text.match(/\bCount\b[^\d]*([\d,]+)/i);
+  if (countMatch?.[1]) {
+    return parseCountMaybe(countMatch[1]);
+  }
+
+  if (/\bNo chats\b/i.test(text)) {
+    return 0;
+  }
+
+  const sessionCount = text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => /^•\s*\[[^\]]+\]/.test(line)).length;
+
+  return sessionCount > 0 ? sessionCount : undefined;
+}
+
+async function fetchTabChatCount(
+  tabId: string,
+  client: ReturnType<typeof getRpClient> = getRpClient()
+): Promise<number | undefined> {
+  if (!client.isConnected) {
+    return undefined;
+  }
+
+  const chatsToolName = resolveToolName(client.tools, "chats");
+  if (!chatsToolName) {
+    return undefined;
+  }
+
+  const result = await client.callTool(chatsToolName, {
+    action: "list",
+    scope: "tab",
+    tab_id: tabId,
+    limit: 1,
+  });
+
+  if (result.isError) {
+    return undefined;
+  }
+
+  const countFromJson = parseChatCountFromJson(extractJsonContent(result.content));
+  if (countFromJson !== undefined) {
+    return countFromJson;
+  }
+
+  return parseChatCountFromText(extractTextContent(result.content));
+}
+
 function findLiveTab(tabs: RpTab[], reference: string | undefined): RpTab | null {
   if (!reference) {
     return null;
@@ -771,34 +988,48 @@ function findLiveTab(tabs: RpTab[], reference: string | undefined): RpTab | null
   return tabs.find((tab) => tab.id === reference || tab.name === reference) ?? null;
 }
 
-function findSoleEmptyTab(tabs: RpTab[]): RpTab | null {
-  if (tabs.length !== 1) {
-    return null;
-  }
-
-  const [tab] = tabs;
-  return tab.selectedFileCount === 0 ? tab : null;
+function isExplicitlyEmptyTab(tab: RpTab): boolean {
+  return tab.selectedFileCount === 0;
 }
 
-function findEmptyBoundTab(tabs: RpTab[]): RpTab | null {
-  return tabs.find((tab) => tab.isBound === true && tab.selectedFileCount === 0) ?? null;
+async function isSafeReusableTab(
+  tab: RpTab,
+  client: ReturnType<typeof getRpClient> = getRpClient()
+): Promise<boolean> {
+  if (!isExplicitlyEmptyTab(tab)) {
+    return false;
+  }
+
+  const chatCount = await fetchTabChatCount(tab.id, client);
+  return chatCount === 0;
 }
 
-function findReusableEmptyTab(tabs: RpTab[]): RpTab | null {
-  const emptyTabs = tabs.filter((tab) => tab.selectedFileCount === 0);
+function orderReusableEmptyTabs(tabs: RpTab[]): RpTab[] {
+  const emptyTabs = tabs.filter(isExplicitlyEmptyTab);
   if (emptyTabs.length === 0) {
-    return null;
+    return [];
   }
 
-  return (
-    emptyTabs.find((tab) => tab.isBound === true) ??
-    emptyTabs.find((tab) => tab.isActive === true) ??
-    emptyTabs[0]
-  );
+  const ordered = [
+    ...emptyTabs.filter((tab) => tab.isBound === true),
+    ...emptyTabs.filter((tab) => tab.isBound !== true && tab.isActive === true),
+    ...emptyTabs.filter((tab) => tab.isBound !== true && tab.isActive !== true),
+  ];
+
+  return ordered.filter((tab, index) => ordered.findIndex((candidate) => candidate.id === tab.id) === index);
 }
 
-function findPreferredActiveTab(tabs: RpTab[]): RpTab | null {
-  return tabs.find((tab) => tab.isActive === true && (tab.selectedFileCount ?? 0) > 0) ?? null;
+async function findReusableSafeTab(
+  tabs: RpTab[],
+  client: ReturnType<typeof getRpClient> = getRpClient()
+): Promise<RpTab | null> {
+  for (const tab of orderReusableEmptyTabs(tabs)) {
+    if (await isSafeReusableTab(tab, client)) {
+      return tab;
+    }
+  }
+
+  return null;
 }
 
 function bindingWindowArgs(windowId: number): Record<string, unknown> {
@@ -1039,37 +1270,30 @@ export async function ensureBindingHasTab(
     return await adoptTab(unknownCurrentTab, false);
   }
 
-  if (!binding.tab) {
-    const preferredActiveTab = findPreferredActiveTab(liveTabs);
-    if (preferredActiveTab) {
-      return await adoptTab(preferredActiveTab, true);
+  const allowHistoricalTabReuse = recoverIfMissing || Boolean(binding.tab);
+  if (allowHistoricalTabReuse) {
+    const branchTabBinding =
+      findMostRecentBindingWithTabForWindow(ctx, binding.windowId) ??
+      findMostRecentAutoSelectionBindingWithTab(ctx.sessionManager.getBranch(), binding.windowId, binding.workspace);
+    const branchTab = findLiveTab(liveTabs, branchTabBinding?.tab);
+    if (branchTab) {
+      return await adoptTab(branchTab, true);
     }
-  }
 
-  const branchTabBinding =
-    findMostRecentBindingWithTabForWindow(ctx, binding.windowId) ??
-    findMostRecentAutoSelectionBindingWithTab(ctx.sessionManager.getBranch(), binding.windowId, binding.workspace);
-  const branchTab = findLiveTab(liveTabs, branchTabBinding?.tab);
-  if (branchTab) {
-    return await adoptTab(branchTab, true);
-  }
-
-  if (liveTabs.length === 0 && branchTabBinding?.tab) {
-    const unknownBranchTab: RpTab = {
-      id: branchTabBinding.tab,
-      name: branchTabBinding.tab,
-    };
-    return await adoptTab(unknownBranchTab, true);
-  }
-
-  const soleEmptyTab = findSoleEmptyTab(liveTabs);
-  if (soleEmptyTab && (reuseSoleEmptyTab || (recoverIfMissing && Boolean(binding.tab)))) {
-    return await adoptTab(soleEmptyTab, true);
+    if (liveTabs.length === 0 && branchTabBinding?.tab) {
+      const unknownBranchTab: RpTab = {
+        id: branchTabBinding.tab,
+        name: branchTabBinding.tab,
+      };
+      return await adoptTab(unknownBranchTab, true);
+    }
   }
 
-  const reusableEmptyTab = findReusableEmptyTab(liveTabs);
-  if (reusableEmptyTab && (!binding.tab || reuseSoleEmptyTab || recoverIfMissing)) {
-    return await adoptTab(reusableEmptyTab, true);
+  if (!binding.tab || reuseSoleEmptyTab || recoverIfMissing) {
+    const reusableSafeTab = await findReusableSafeTab(liveTabs, client);
+    if (reusableSafeTab) {
+      return await adoptTab(reusableSafeTab, true);
+    }
   }
 
   if (!createIfMissing && !(recoverIfMissing && binding.tab)) {

package/extensions/repoprompt-mcp/src/config.ts

@@ -4,7 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { execFileSync } from "node:child_process";
-import type { RpConfig } from "./types.js";
+import { DIFF_VIEW_MODES, type DiffViewMode, type RpConfig } from "./types.js";
 
 // Default configuration
 const DEFAULT_CONFIG: RpConfig = {
@@ -12,7 +12,9 @@ const DEFAULT_CONFIG: RpConfig = {
   persistBinding: true,
   confirmDeletes: true,
   confirmEdits: false,
-  collapsedMaxLines: 15,
+  collapsedMaxLines: 3,
+  diffViewMode: "auto",
+  diffSplitMinWidth: 120,
   suppressHostDisconnectedLog: true,
 
   // Off by default: preserves RepoPrompt's default read_file behavior unless explicitly enabled
@@ -133,6 +135,20 @@ function findRepoPromptServer(): { command: string; args: string[] } | null {
   return null;
 }
 
+function clampNumber(value: unknown, min: number, max: number, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+
+function toDiffViewMode(value: unknown): DiffViewMode {
+  return DIFF_VIEW_MODES.includes(value as DiffViewMode)
+    ? (value as DiffViewMode)
+    : (DEFAULT_CONFIG.diffViewMode as DiffViewMode);
+}
+
 /**
  * Load extension configuration
  */
@@ -181,6 +197,9 @@ export function loadConfig(overrides?: Partial<RpConfig>): RpConfig {
     config = { ...config, ...overrides };
   }
 
+  config.diffViewMode = toDiffViewMode(config.diffViewMode);
+  config.diffSplitMinWidth = clampNumber(config.diffSplitMinWidth, 70, 240, DEFAULT_CONFIG.diffSplitMinWidth ?? 120);
+
   return config;
 }
 

package/extensions/repoprompt-mcp/src/diff-presentation.ts

@@ -0,0 +1,79 @@
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+import type { RpConfig } from "./types.js";
+
+export interface DiffSummaryStats {
+  added: number;
+  removed: number;
+  hunks: number;
+  files: number;
+}
+
+export type DiffPresentationMode = "split" | "unified" | "compact" | "summary";
+
+const MIN_COMPACT_DIFF_WIDTH = 8;
+const MIN_UNIFIED_DIFF_WIDTH = 18;
+
+function pluralize(count: number, singular: string): string {
+  return count === 1 ? singular : `${singular}s`;
+}
+
+export function normalizeDiffRenderWidth(width: number): number {
+  if (!Number.isFinite(width)) {
+    return 0;
+  }
+
+  return Math.max(0, Math.floor(width));
+}
+
+export function resolveDiffPresentationMode(
+  config: Pick<RpConfig, "diffViewMode" | "diffSplitMinWidth">,
+  width: number,
+  canRenderSplitLayout: boolean
+): DiffPresentationMode {
+  const safeWidth = normalizeDiffRenderWidth(width);
+
+  if (safeWidth < MIN_COMPACT_DIFF_WIDTH) {
+    return "summary";
+  }
+
+  if (safeWidth < MIN_UNIFIED_DIFF_WIDTH) {
+    return "compact";
+  }
+
+  switch (config.diffViewMode) {
+    case "split":
+      return canRenderSplitLayout ? "split" : "unified";
+    case "unified":
+      return "unified";
+    case "auto":
+    default:
+      return safeWidth >= (config.diffSplitMinWidth ?? 120) && canRenderSplitLayout
+        ? "split"
+        : "unified";
+  }
+}
+
+export function buildDiffSummaryText(stats: DiffSummaryStats, width: number): string {
+  const safeWidth = normalizeDiffRenderWidth(width);
+  if (safeWidth === 0) {
+    return "";
+  }
+
+  const summaryCandidates = [
+    `↳ diff +${stats.added} -${stats.removed} • ${stats.hunks} ${pluralize(stats.hunks, "hunk")} • ${stats.files} ${pluralize(stats.files, "file")}`,
+    `↳ diff +${stats.added} -${stats.removed} • ${stats.hunks}h • ${stats.files}f`,
+    `↳ diff +${stats.added} -${stats.removed}`,
+    `+${stats.added} -${stats.removed}`,
+    "diff",
+    "…",
+  ];
+
+  for (const candidate of summaryCandidates) {
+    if (visibleWidth(candidate) <= safeWidth) {
+      return candidate;
+    }
+  }
+
+  return truncateToWidth(summaryCandidates[summaryCandidates.length - 1] ?? "", safeWidth, "");
+}