@pi-unipi/utility 2.6.1 → 2.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/utility",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Utility commands and tools for Pi coding agent — lifecycle, diagnostics, cache, analytics, display, batch execution",
   "type": "module",
   "main": "src/index.ts",
@@ -36,9 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.6.1",
-    "diff": "^7.0.0",
-    "shiki": "^4.0.2"
+    "@pi-unipi/core": "2.6.1"
   },
   "devDependencies": {
     "@types/diff": "^7.0.2"
@@ -52,8 +50,12 @@
     "test": "npx tsx --test tests/**/*.test.ts"
   },
   "pi": {
-    "extensions": [],
-    "skills": [],
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ],
     "prompts": [],
     "themes": []
   }

package/src/commands.ts

@@ -21,8 +21,7 @@ import { cleanupStale, formatCleanupReport } from "./lifecycle/cleanup.js";
 import { runDiagnostics, formatDiagnosticsReport } from "./diagnostics/engine.js";
 import { getEnvironmentInfo, formatEnvironmentInfo } from "./tools/env.js";
 import type { NameBadgeState } from "./tui/name-badge-state.js";
-import { readBadgeSettings, updateBadgeSetting, formatBadgeSettings } from "./tui/badge-settings.js";
-import { BadgeSettingsTui } from "./tui/badge-settings-tui.js";
+import { readBadgeSettings, updateBadgeSetting, formatBadgeSettings } from "./settings.js";
 import { UtilSettingsTui } from "./tui/util-settings-tui.js";
 
 /** Send a markdown response via pi.sendMessage */
@@ -77,14 +76,14 @@ export function registerNameBadgeCommands(
 
   // ─── /unipi:badge-toggle — configure badge settings ─────────────────────
   pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.BADGE_TOGGLE}`, {
-    description: "Configure badge settings (autoGen, badgeEnabled, agentTool)",
+    description: "Configure badge settings (autoGen, badgeEnabled, agentTool, herdrSync)",
     handler: async (args: string, ctx: ExtensionContext) => {
       // Parse args: /unipi:badge-settings [key] [on|off]
       const parts = args.trim().split(/\s+/);
       if (parts.length >= 2 && parts[0]) {
-        const key = parts[0] as "autoGen" | "badgeEnabled" | "agentTool";
+        const key = parts[0] as "autoGen" | "badgeEnabled" | "agentTool" | "herdrSync";
         const value = parts[1]?.toLowerCase();
-        if ("autoGen|badgeEnabled|agentTool".includes(key)) {
+        if ("autoGen|badgeEnabled|agentTool|herdrSync".includes(key)) {
           const boolValue = value === "on" || value === "true" || value === "1";
           updateBadgeSetting(key, boolValue);
           ctx.ui.notify(`Badge ${key} set to ${boolValue}`, "info");

package/src/herdr-sync.ts

@@ -0,0 +1,136 @@
+/**
+ * @pi-unipi/utility — Herdr pane title sync
+ *
+ * When running inside a Herdr pane, pushes the pi session name to Herdr's
+ * socket API (`pane.report_metadata` with `title`). Herdr displays the title
+ * in the pane border / agent panel — always visible, never scrolls away.
+ *
+ * This is the scroll-proof session name display: the in-TUI badge overlay
+ * scrolls with content (pi renders to the primary buffer), but Herdr's pane
+ * border is drawn by Herdr itself outside the terminal scrollback.
+ *
+ * Detection: Herdr sets HERDR_ENV=1 and HERDR_SOCKET_PATH + HERDR_PANE_ID
+ * in every pane it spawns (same env the official herdr-pi integration uses).
+ */
+
+import { createConnection } from "node:net";
+
+/** Push timeout — never block the agent on a slow socket. */
+const SEND_TIMEOUT_MS = 500;
+
+export interface HerdrEnv {
+  enabled: boolean;
+  socketPath?: string;
+  paneId?: string;
+  tabId?: string;
+}
+
+/** Read Herdr environment (call once per session_start, cheap). */
+export function detectHerdr(): HerdrEnv {
+  const env = process.env.HERDR_ENV;
+  const socketPath = process.env.HERDR_SOCKET_PATH;
+  const paneId = process.env.HERDR_PANE_ID;
+  const tabId = process.env.HERDR_TAB_ID;
+  if (env === "1" && socketPath && paneId) {
+    return { enabled: true, socketPath, paneId, tabId };
+  }
+  return { enabled: false };
+}
+
+function sendRequest(socketPath: string, request: unknown): Promise<void> {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      resolve();
+    };
+    const socket = createConnection(socketPath);
+    socket.on("error", finish);
+    socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on("data", finish);
+    socket.on("end", finish);
+    const timeout = setTimeout(finish, SEND_TIMEOUT_MS);
+    timeout.unref?.();
+  });
+}
+
+let reportSeq = Date.now();
+
+/** Only rename the tab when its label is a default numeric one (1-3 digits) — never clobber a user-set name. */
+const DEFAULT_TAB_LABEL = /^\d{1,3}$/;
+
+async function fetchJson(socketPath: string, method: string, params: Record<string, unknown>, extract: (result: any) => Record<string, unknown> | null): Promise<Record<string, unknown> | null> {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (value: Record<string, unknown> | null) => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      resolve(value);
+    };
+    const socket = createConnection(socketPath);
+    let buffer = "";
+    socket.on("error", () => finish(null));
+    socket.on("connect", () =>
+      socket.write(
+        `${JSON.stringify({ id: `unipi:fetch:${method}:${Date.now()}`, method, params })}\n`,
+      ),
+    );
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      try {
+        const parsed = JSON.parse(buffer);
+        finish(extract(parsed?.result));
+      } catch {
+        /* keep buffering */
+      }
+    });
+    socket.on("end", () => finish(null));
+    const timeout = setTimeout(() => finish(null), SEND_TIMEOUT_MS);
+    timeout.unref?.();
+  });
+}
+
+/**
+ * Push the session name to Herdr as the pane title, and as the tab label
+ * when the tab still has its default numeric label.
+ * Fire-and-forget: never throws, resolves after send timeout at worst.
+ */
+export async function syncPaneTitle(env: HerdrEnv, sessionName: string | null): Promise<void> {
+  if (!env.enabled || !env.socketPath || !env.paneId) return;
+  reportSeq += 1;
+  const params: Record<string, unknown> = {
+    pane_id: env.paneId,
+    source: "unipi:badge",
+    seq: reportSeq,
+  };
+  if (sessionName) {
+    params.title = sessionName;
+  } else {
+    params.clear_title = true;
+  }
+  // Best effort — errors are swallowed by sendRequest's error handler.
+  await sendRequest(env.socketPath, {
+    id: `unipi:badge:title:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+    method: "pane.report_metadata",
+    params,
+  });
+
+  // Also sync the tab label so the name is visible in the tab bar (single-pane
+  // tabs don't render pane borders, so the pane title alone is invisible there).
+  // Only rename when the label is still the default numeric one — a user-set
+  // name always wins.
+  if (sessionName && env.tabId) {
+    const tab = await fetchJson(env.socketPath, "tab.get", { tab_id: env.tabId }, (r) => r?.tab ?? null);
+    const label = tab?.label;
+    if (typeof label !== "string" || DEFAULT_TAB_LABEL.test(label)) {
+      await sendRequest(env.socketPath, {
+        id: `unipi:badge:tab:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+        method: "tab.rename",
+        params: { tab_id: env.tabId, label: sessionName },
+      });
+    }
+  }
+}

package/src/index.ts

@@ -26,16 +26,14 @@ import {
 } from "@pi-unipi/core";
 import { registerUtilityCommands, registerNameBadgeCommands } from "./commands.js";
 import { NameBadgeState } from "./tui/name-badge-state.js";
-import { readBadgeSettings } from "./tui/badge-settings.js";
-import { readDiffSettings } from "./diff/settings.js";
-import { registerEnhancedWriteTool, registerEnhancedEditTool } from "./diff/wrapper.js";
+import { readBadgeSettings } from "./settings.js";
 import { getLifecycle } from "./lifecycle/process.js";
 import { getAnalyticsCollector } from "./analytics/collector.js";
 import { registerInfoScreen } from "./info-screen.js";
 import { PrefixCacheTracker, formatPrefixCacheStats } from "./prefix-cache.js";
 
 /** Re-export readBadgeSettings for cross-package use */
-export { readBadgeSettings } from "./tui/badge-settings.js";
+export { readBadgeSettings } from "./settings.js";
 
 /** Package version */
 const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
@@ -155,12 +153,15 @@ export default function (pi: ExtensionAPI) {
     // Restore name badge if it was visible in previous session
     await nameBadgeState.restore(pi, ctx);
 
-    // Register diff-enhanced tools if enabled
-    const diffSettings = readDiffSettings();
-    if (diffSettings.enabled) {
-      const cwd = process.cwd();
-      registerEnhancedWriteTool(pi, cwd);
-      registerEnhancedEditTool(pi, cwd);
+    // Auto-show badge on session start if enabled in settings and UI is available.
+    // The badge shows "Set a name" placeholder until a name is generated.
+    // Previously the badge only showed after the first agent_end, which meant it
+    // was absent on restart until the user sent a message.
+    if (ctx?.hasUI && !nameBadgeState.isVisible()) {
+      const badgeSettings = readBadgeSettings();
+      if (badgeSettings.badgeEnabled) {
+        await nameBadgeState.show(pi, ctx);
+      }
     }
 
     // Write model cache for TUI components
@@ -274,64 +275,6 @@ export default function (pi: ExtensionAPI) {
  * Register utility tools.
  */
 function registerUtilityTools(pi: ExtensionAPI, nameBadgeState: NameBadgeState): void {
-  // ctx_batch — atomic batch execution
-  pi.registerTool({
-    name: UTILITY_TOOLS.BATCH,
-    label: "Batch Execute",
-    description:
-      "Execute a batch of commands atomically with rollback support. " +
-      "Accepts an array of {type, name, args} objects. " +
-      "Options: failFast (default true), commandTimeoutMs, totalTimeoutMs.",
-    promptSnippet: "Run multiple commands as an atomic batch.",
-    parameters: {
-      type: "object",
-      properties: {
-        commands: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              type: { type: "string", enum: ["command", "tool", "search"] },
-              name: { type: "string" },
-              args: { type: "object" },
-            },
-            required: ["type", "name"],
-          },
-        },
-        options: {
-          type: "object",
-          properties: {
-            failFast: { type: "boolean" },
-            commandTimeoutMs: { type: "number" },
-            totalTimeoutMs: { type: "number" },
-          },
-        },
-      },
-      required: ["commands"],
-    },
-    async execute(_toolCallId, params) {
-      const { commands, options } = params as unknown as {
-        commands: Array<{ type: string; name: string; args?: Record<string, unknown> }>;
-        options?: Record<string, unknown>;
-      };
-
-      // Tool implementation delegates to batch executor
-      // The actual executor must be provided by the host
-      return {
-        content: [
-          {
-            type: "text",
-            text:
-              "ctx_batch requires a command executor from the host environment. " +
-              `Received ${commands.length} commands. ` +
-              "Use BatchBuilder or executeBatch() directly in code.",
-          },
-        ],
-        details: { commands, options },
-      };
-    },
-  });
-
   // ctx_env — environment info
   pi.registerTool({
     name: UTILITY_TOOLS.ENV,

package/src/lifecycle/cleanup.ts

@@ -4,7 +4,7 @@
  * Cleans stale DBs, temp files, old sessions across all unipi modules.
  */
 
-import { existsSync, statSync, readdirSync, unlinkSync, rmdirSync } from "node:fs";
+import { existsSync, statSync, readdirSync, unlinkSync, rmSync } from "node:fs";
 import { join, resolve, basename } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import type { CleanupReport, CleanupResult, CleanupOptions } from "../types.js";
@@ -229,21 +229,7 @@ function cleanSessions(options: Required<CleanupOptions>): CleanupResult {
         result.paths.push(fullPath);
         if (!options.dryRun) {
           try {
-            // Remove directory contents then directory
-            const removeRecursive = (dir: string) => {
-              const items = readdirSync(dir);
-              for (const item of items) {
-                const itemPath = join(dir, item);
-                const itemStats = statSync(itemPath);
-                if (itemStats.isDirectory()) {
-                  removeRecursive(itemPath);
-                } else {
-                  unlinkSync(itemPath);
-                }
-              }
-              rmdirSync(dir);
-            };
-            removeRecursive(fullPath);
+            rmSync(fullPath, { recursive: true, force: true });
             result.removed++;
           } catch {
             // Best effort

package/src/{diff/settings.ts → settings.ts}

@@ -1,68 +1,46 @@
 /**
- * @pi-unipi/utility — Unified Settings Manager
+ * @pi-unipi/utility — Settings Manager
  *
- * Manages both badge and diff settings in a single `.unipi/config/util-settings.json` file.
+ * Manages badge settings in `.unipi/config/util-settings.json`.
  * Migrates from legacy `badge.json` on first read.
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-/** Diff rendering settings */
-export interface DiffSettings {
-  /** Enable Shiki-powered diff rendering for write/edit tools */
-  enabled: boolean;
-  /** Diff theme preset: "default" | "midnight" | "subtle" | "neon" */
-  theme: string;
-  /** Shiki syntax theme name */
-  shikiTheme: string;
-  /** Minimum terminal columns for split view */
-  splitMinWidth: number;
-}
-
-/** Badge settings (matches existing BadgeSettings interface) */
+/** Badge settings */
 export interface BadgeSettingsSection {
   autoGen: boolean;
   badgeEnabled: boolean;
   agentTool: boolean;
   generationModel: string;
+  /** Sync session name to herdr pane title + tab label (when running inside herdr). */
+  herdrSync: boolean;
 }
 
 /** Unified utility settings */
 export interface UtilSettings {
   badge: BadgeSettingsSection;
-  diff: DiffSettings;
 }
 
-/** Default diff settings */
-const DEFAULT_DIFF_SETTINGS: DiffSettings = {
-  enabled: true,
-  theme: "default",
-  shikiTheme: "github-dark",
-  splitMinWidth: 150,
-};
-
 /** Default badge settings */
 const DEFAULT_BADGE_SETTINGS: BadgeSettingsSection = {
   autoGen: true,
   badgeEnabled: true,
   agentTool: true,
   generationModel: "inherit",
+  herdrSync: true,
 };
 
 /** Default unified settings */
 const DEFAULT_SETTINGS: UtilSettings = {
   badge: { ...DEFAULT_BADGE_SETTINGS },
-  diff: { ...DEFAULT_DIFF_SETTINGS },
 };
 
 /** Config file paths */
 const UTIL_SETTINGS_FILE = ".unipi/config/util-settings.json";
 const BADGE_CONFIG_FILE = ".unipi/config/badge.json";
 
-/**
- * Get absolute path for a config file relative to cwd.
- */
 function getConfigPath(file: string): string {
   return path.resolve(process.cwd(), file);
 }
@@ -81,58 +59,41 @@ function readLegacyBadgeSettings(): BadgeSettingsSection | null {
       badgeEnabled: typeof parsed.badgeEnabled === "boolean" ? parsed.badgeEnabled : DEFAULT_BADGE_SETTINGS.badgeEnabled,
       agentTool: typeof parsed.agentTool === "boolean" ? parsed.agentTool : DEFAULT_BADGE_SETTINGS.agentTool,
       generationModel: typeof parsed.generationModel === "string" ? parsed.generationModel : DEFAULT_BADGE_SETTINGS.generationModel,
+      herdrSync: typeof parsed.herdrSync === "boolean" ? parsed.herdrSync : DEFAULT_BADGE_SETTINGS.herdrSync,
     };
   } catch {
     return null;
   }
 }
 
-/**
- * Atomic write: write to temp file then rename.
- * Prevents corruption if two instances write simultaneously.
- */
 function atomicWrite(filePath: string, data: string): void {
   const tmpPath = filePath + ".tmp";
   fs.writeFileSync(tmpPath, data, "utf-8");
   fs.renameSync(tmpPath, filePath);
 }
 
-/**
- * Read the unified util-settings.json.
- * On first read, migrates from badge.json if it exists.
- * Returns defaults if no config exists.
- */
 export function readUtilSettings(): UtilSettings {
   try {
     const configPath = getConfigPath(UTIL_SETTINGS_FILE);
 
-    // Check if unified config exists
     if (fs.existsSync(configPath)) {
       const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       return normalizeSettings(parsed);
     }
 
-    // Migration: import from badge.json if it exists
     const legacyBadge = readLegacyBadgeSettings();
     if (legacyBadge) {
-      const migrated: UtilSettings = {
-        badge: legacyBadge,
-        diff: { ...DEFAULT_DIFF_SETTINGS },
-      };
+      const migrated: UtilSettings = { badge: legacyBadge };
       writeUtilSettings(migrated);
       return migrated;
     }
 
-    // No config at all — return defaults (don't write yet)
-    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS }, diff: { ...DEFAULT_DIFF_SETTINGS } };
+    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS } };
   } catch {
-    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS }, diff: { ...DEFAULT_DIFF_SETTINGS } };
+    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS } };
   }
 }
 
-/**
- * Write the full unified settings to disk.
- */
 export function writeUtilSettings(settings: UtilSettings): void {
   try {
     const configPath = getConfigPath(UTIL_SETTINGS_FILE);
@@ -146,9 +107,6 @@ export function writeUtilSettings(settings: UtilSettings): void {
   }
 }
 
-/**
- * Normalize a parsed JSON object into valid UtilSettings.
- */
 function normalizeSettings(parsed: any): UtilSettings {
   return {
     badge: {
@@ -156,44 +114,48 @@ function normalizeSettings(parsed: any): UtilSettings {
       badgeEnabled: typeof parsed?.badge?.badgeEnabled === "boolean" ? parsed.badge.badgeEnabled : DEFAULT_BADGE_SETTINGS.badgeEnabled,
       agentTool: typeof parsed?.badge?.agentTool === "boolean" ? parsed.badge.agentTool : DEFAULT_BADGE_SETTINGS.agentTool,
       generationModel: typeof parsed?.badge?.generationModel === "string" ? parsed.badge.generationModel : DEFAULT_BADGE_SETTINGS.generationModel,
-    },
-    diff: {
-      enabled: typeof parsed?.diff?.enabled === "boolean" ? parsed.diff.enabled : DEFAULT_DIFF_SETTINGS.enabled,
-      theme: typeof parsed?.diff?.theme === "string" ? parsed.diff.theme : DEFAULT_DIFF_SETTINGS.theme,
-      shikiTheme: typeof parsed?.diff?.shikiTheme === "string" ? parsed.diff.shikiTheme : DEFAULT_DIFF_SETTINGS.shikiTheme,
-      splitMinWidth: typeof parsed?.diff?.splitMinWidth === "number" ? parsed.diff.splitMinWidth : DEFAULT_DIFF_SETTINGS.splitMinWidth,
+      herdrSync: typeof parsed?.badge?.herdrSync === "boolean" ? parsed.badge.herdrSync : DEFAULT_BADGE_SETTINGS.herdrSync,
     },
   };
 }
 
-/**
- * Read only the diff settings section.
- */
-export function readDiffSettings(): DiffSettings {
-  return readUtilSettings().diff;
+/** Read only the badge settings section. */
+export function readBadgeSettings(): BadgeSettingsSection {
+  return readUtilSettings().badge;
 }
 
-/**
- * Write partial diff settings (merged with existing).
- */
-export function writeDiffSettings(partial: Partial<DiffSettings>): void {
+/** Write partial badge settings (merged with existing). */
+export function writeBadgeSettings(partial: Partial<BadgeSettingsSection>): void {
   const settings = readUtilSettings();
-  settings.diff = { ...settings.diff, ...partial };
+  settings.badge = { ...settings.badge, ...partial };
   writeUtilSettings(settings);
 }
 
-/**
- * Read only the badge settings section.
- */
-export function readBadgeSettingsFromUtil(): BadgeSettingsSection {
-  return readUtilSettings().badge;
+/** Update a single badge setting. */
+export function updateBadgeSetting<K extends keyof BadgeSettingsSection>(
+  key: K,
+  value: BadgeSettingsSection[K],
+): BadgeSettingsSection {
+  const settings = readBadgeSettings();
+  settings[key] = value;
+  writeBadgeSettings(settings);
+  return settings;
 }
 
-/**
- * Write partial badge settings (merged with existing).
- */
-export function writeBadgeSettingsToUtil(partial: Partial<BadgeSettingsSection>): void {
-  const settings = readUtilSettings();
-  settings.badge = { ...settings.badge, ...partial };
-  writeUtilSettings(settings);
+/** Format badge settings for display. */
+export function formatBadgeSettings(settings: BadgeSettingsSection): string {
+  const toggle = (v: boolean) => (v ? "✓ enabled" : "✗ disabled");
+  return [
+    "## Badge Settings",
+    "",
+    `| Setting | Status | Description |`,
+    `|---------|--------|-------------|`,
+    `| Auto Generate | ${toggle(settings.autoGen)} | Generate name on first message |`,
+    `| Badge Enabled | ${toggle(settings.badgeEnabled)} | Show badge overlay |`,
+    `| Agent Tool | ${toggle(settings.agentTool)} | Allow agents to call set_session_name |`,
+    `| Herdr Sync | ${toggle(settings.herdrSync)} | Sync session name to herdr tab/pane title |`,
+    `| Generation Model | ${settings.generationModel} | Model for badge name generation |`,
+    "",
+    `Config: .unipi/config/util-settings.json`,
+  ].join("\n");
 }

package/src/tui/name-badge-state.ts

@@ -11,7 +11,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { UNIPI_EVENTS, emitEvent } from "@pi-unipi/core";
 import { NameBadgeComponent } from "./name-badge.js";
-import { readBadgeSettings } from "./badge-settings.js";
+import { readBadgeSettings } from "../settings.js";
+import { detectHerdr, syncPaneTitle, type HerdrEnv } from "../herdr-sync.js";
 
 /** Overlay handle from ctx.ui.custom() */
 interface OverlayHandle {
@@ -54,6 +55,7 @@ export class NameBadgeState {
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private component: NameBadgeComponent | null = null;
   private genTimeout: ReturnType<typeof setTimeout> | null = null;
+  private herdr: HerdrEnv = { enabled: false };
 
   /** Whether the badge is currently visible */
   isVisible(): boolean {
@@ -89,6 +91,13 @@ export class NameBadgeState {
   ): Promise<void> {
     if (this.overlayHandle) return; // Already showing
 
+    // Detect Herdr once per session; sync the current name to its pane title.
+    this.herdr = detectHerdr();
+    if (this.herdr.enabled && readBadgeSettings().herdrSync) {
+      const name = this.safeGetName(pi);
+      void syncPaneTitle(this.herdr, name);
+    }
+
     const name = this.safeGetName(pi);
     this.currentName = name;
     this.visible = true;
@@ -169,7 +178,6 @@ export class NameBadgeState {
       const badgeEntry = entries.findLast(
         (e: any) => e.type === "custom" && e.customType === BADGE_ENTRY_TYPE,
       );
-
       if (badgeEntry?.data?.visible) {
         await this.show(pi, ctx);
       }
@@ -224,6 +232,10 @@ export class NameBadgeState {
       this.currentName = name;
       this.component?.setName(name);
       this.overlayHandle?.requestRender?.();
+      // Sync to Herdr pane title (scroll-proof display)
+      if (readBadgeSettings().herdrSync) {
+        void syncPaneTitle(this.herdr, name);
+      }
       // Clear generation timeout if active
       this.clearGenTimeout();
     } catch {
@@ -251,6 +263,10 @@ export class NameBadgeState {
         this.currentName = name;
         this.component?.setName(name);
         this.overlayHandle?.requestRender?.();
+        // Sync to Herdr pane title (scroll-proof display)
+        if (readBadgeSettings().herdrSync) {
+          void syncPaneTitle(this.herdr, name);
+        }
       }
     }, POLL_INTERVAL_MS);
   }

package/src/tui/name-badge.ts

@@ -96,13 +96,14 @@ export class NameBadgeComponent implements Component {
       ? this.theme.fg(fgColor as any, displayText)
       : displayText;
 
-    // Build lines with opaque background spanning full width
-    const topLine = bgFn(border("╭" + "─".repeat(innerWidth) + "╮"));
+    // Build single line with opaque background (no top/bottom borders to
+    // minimize vertical blocking — the badge stays at the top of the screen
+    // and a single line blocks far less content than a 3-line box when
+    // scrolling up to read history).
     const contentLine = bgFn(
       border("│") + " ".repeat(leftPad) + nameStyled + " ".repeat(rightPad) + border("│"),
     );
-    const bottomLine = bgFn(border("╰" + "─".repeat(innerWidth) + "╯"));
 
-    return [topLine, contentLine, bottomLine];
+    return [contentLine];
   }
 }