@llblab/pi-actors 0.17.0 → 0.18.0

package/lib/actor-inspector-tui.ts

@@ -6,6 +6,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+import { visibleWidth } from "@earendil-works/pi-tui";
+
 import type { ActorMessage } from "./actor-messages.ts";
 import * as Paths from "./paths.ts";
 
@@ -13,6 +15,7 @@ export interface ActorInspectorPreview {
   body_preview?: string;
   channel: "broadcast" | "direct" | "room";
   from?: string;
+  from_display?: string;
   run: string;
   sequence?: number;
   summary?: string;
@@ -32,15 +35,25 @@ export interface ActorInspectorWidgetStyle {
   type?: (text: string) => string;
 }
 
-export type ActorInspectorVerbosity = "compact" | "verbose";
+export interface ActorInspectorRenderOptions {}
+
+export interface ActorInspectorItemViewOptions {
+  sequence: number;
+}
 
-export interface ActorInspectorRenderOptions {
-  verbosity?: ActorInspectorVerbosity;
+export interface ActorInspectorRosterMember {
+  address: string;
+  display?: string;
+  role?: string;
+  status?: string;
 }
 
 export interface ActorInspectorPreviewReadOptions {
   ownerId?: string;
   currentRunOnly?: boolean;
+  channels?: ActorInspectorPreview["channel"][];
+  mention?: string;
+  roomLimitPerRun?: number;
 }
 
 function asRecord(value: unknown): Record<string, unknown> {
@@ -78,9 +91,12 @@ function previewValue(value: unknown, maxLength = 320): string | undefined {
     : compact;
 }
 
-function channelFor(message: Pick<ActorMessage, "to">): ActorInspectorPreview["channel"] {
+function channelFor(
+  message: Pick<ActorMessage, "to">,
+): ActorInspectorPreview["channel"] {
   if (message.to.startsWith("room:")) return "room";
-  if (message.to === "coordinator" || message.to.startsWith("session:")) return "broadcast";
+  if (message.to === "coordinator" || message.to.startsWith("session:"))
+    return "broadcast";
   return "direct";
 }
 
@@ -88,16 +104,27 @@ function previewFromMessage(
   run: string,
   message: Record<string, unknown>,
   timestamp: string,
+  displayNames: Record<string, string> = {},
 ): ActorInspectorPreview | undefined {
   const to = typeof message.to === "string" ? message.to : undefined;
   const type = typeof message.type === "string" ? message.type : undefined;
   if (!to || !type) return undefined;
   const from = typeof message.from === "string" ? message.from : undefined;
-  const summary = typeof message.summary === "string" ? message.summary : undefined;
+  const summary =
+    typeof message.summary === "string" ? message.summary : undefined;
+  const body = asRecord(message.body);
+  const display = from
+    ? typeof body.display === "string" && body.display.trim()
+      ? body.display.trim()
+      : displayNames[from]
+    : undefined;
   return {
-    ...(previewValue(message.body) ? { body_preview: previewValue(message.body) } : {}),
+    ...(previewValue(message.body)
+      ? { body_preview: previewValue(message.body) }
+      : {}),
     channel: channelFor({ to }),
     ...(from ? { from } : {}),
+    ...(display ? { from_display: display } : {}),
     run,
     ...(summary ? { summary } : {}),
     timestamp,
@@ -106,30 +133,71 @@ function previewFromMessage(
   };
 }
 
-function readRoomPreviews(run: string, stateDir: string): ActorInspectorPreview[] {
+function readRoomRosterRecords(
+  stateDir: string,
+  room: string,
+): Record<string, Record<string, unknown>> {
+  try {
+    return JSON.parse(
+      fs.readFileSync(path.join(stateDir, "rooms", room, "roster.json"), "utf8"),
+    ) as Record<string, Record<string, unknown>>;
+  } catch {
+    return {};
+  }
+}
+
+function memberDisplay(_address: string, member: Record<string, unknown>): string | undefined {
+  const display = typeof member.display === "string" ? member.display.trim() : "";
+  return display || undefined;
+}
+
+function readRoomDisplayNames(stateDir: string, room: string): Record<string, string> {
+  const roster = readRoomRosterRecords(stateDir, room);
+  return Object.fromEntries(
+    Object.entries(roster).flatMap(([address, member]) => {
+      const display = memberDisplay(address, member);
+      return display ? [[address, display]] : [];
+    }),
+  );
+}
+
+function readRoomPreviews(
+  run: string,
+  stateDir: string,
+  limitPerRun?: number,
+): ActorInspectorPreview[] {
   const roomsDir = path.join(stateDir, "rooms");
   try {
-    return fs
+    const previews = fs
       .readdirSync(roomsDir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory())
-      .flatMap((entry) =>
-        readJsonLines(path.join(roomsDir, entry.name, "messages.jsonl"))
+      .flatMap((entry) => {
+        const displayNames = readRoomDisplayNames(stateDir, entry.name);
+        return readJsonLines(path.join(roomsDir, entry.name, "messages.jsonl"))
           .map((message) =>
             previewFromMessage(
               run,
               message,
               String(message.received_at ?? message.timestamp ?? ""),
+              displayNames,
             ),
           )
-          .filter((preview): preview is ActorInspectorPreview => Boolean(preview)),
-      );
+          .filter((preview): preview is ActorInspectorPreview =>
+            Boolean(preview),
+          );
+      });
+    const limit = Number.isFinite(limitPerRun) ? Math.max(0, Number(limitPerRun)) : undefined;
+    return limit === undefined ? previews : previews.slice(-limit);
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
     return [];
   }
 }
 
-function readInboxPreviews(run: string, stateDir: string): ActorInspectorPreview[] {
+function readInboxPreviews(
+  run: string,
+  stateDir: string,
+): ActorInspectorPreview[] {
   return readJsonLines(path.join(stateDir, "inbox.jsonl"))
     .map((message) =>
       previewFromMessage(
@@ -141,7 +209,10 @@ function readInboxPreviews(run: string, stateDir: string): ActorInspectorPreview
     .filter((preview): preview is ActorInspectorPreview => Boolean(preview));
 }
 
-function readOutboxPreviews(run: string, stateDir: string): ActorInspectorPreview[] {
+function readOutboxPreviews(
+  run: string,
+  stateDir: string,
+): ActorInspectorPreview[] {
   return readJsonLines(path.join(stateDir, "outbox.jsonl"))
     .map((event) => {
       const message = asRecord(event.message ?? event);
@@ -169,6 +240,25 @@ function matchesOwner(stateDir: string, ownerId: string | undefined): boolean {
   return ownerId === undefined || getRunOwnerId(stateDir) === ownerId;
 }
 
+function matchesPreviewFilter(
+  preview: ActorInspectorPreview,
+  options: ActorInspectorPreviewReadOptions,
+): boolean {
+  if (options.channels?.length && !options.channels.includes(preview.channel)) {
+    return false;
+  }
+  const mention = options.mention?.trim().toLowerCase();
+  if (!mention) return true;
+  return [
+    preview.from,
+    preview.from_display,
+    preview.to,
+    preview.type,
+    preview.summary,
+    preview.body_preview,
+  ].some((value) => value?.toLowerCase().includes(mention));
+}
+
 export function readActorInspectorPreviews(
   stateRoot = Paths.getRunStateRoot(),
   limit = 8,
@@ -182,20 +272,23 @@ export function readActorInspectorPreviews(
         const stateDir = path.join(stateRoot, entry.name);
         if (!matchesOwner(stateDir, options.ownerId)) return [];
         return [
-          ...readRoomPreviews(entry.name, stateDir),
+          ...readRoomPreviews(entry.name, stateDir, options.roomLimitPerRun),
           ...readInboxPreviews(entry.name, stateDir),
           ...readOutboxPreviews(entry.name, stateDir),
         ];
       })
       .filter((preview) => preview.timestamp)
       .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    const currentRun = options.currentRunOnly ? previews.at(-1)?.run : undefined;
+    const currentRun = options.currentRunOnly
+      ? previews.at(-1)?.run
+      : undefined;
     return previews
       .filter((preview) => !currentRun || preview.run === currentRun)
+      .filter((preview) => matchesPreviewFilter(preview, options))
       .map((preview, index) => ({
         ...preview,
         sequence: index + 1,
-        stripe: index % 2 === 0,
+        stripe: index % 2 === 1,
       }))
       .slice(-Math.max(1, limit));
   } catch (error) {
@@ -210,9 +303,10 @@ function shorten(
   options: { preserveSpaces?: boolean } = { preserveSpaces: true },
 ): string {
   if (!value) return "-";
-  const compact = options.preserveSpaces === false
-    ? value.replaceAll(/\s+/g, "_")
-    : value.replaceAll(/\s+/g, " ").trim();
+  const compact =
+    options.preserveSpaces === false
+      ? value.replaceAll(/\s+/g, "_")
+      : value.replaceAll(/\s+/g, " ").trim();
   if (maxLength <= 1) return compact.slice(0, Math.max(0, maxLength));
   return compact.length > maxLength
     ? `${compact.slice(0, Math.max(0, maxLength - 1))}…`
@@ -233,14 +327,21 @@ function roomName(address: string): string | undefined {
   return room ? room[1] : undefined;
 }
 
+function routeActorText(preview: ActorInspectorPreview): string {
+  return preview.from_display || actorName(preview.from);
+}
+
 function routeText(preview: ActorInspectorPreview): string {
-  const actor = actorName(preview.from);
+  const actor = routeActorText(preview);
   if (preview.channel === "room") return `${actor} # all`;
   if (preview.channel === "broadcast") return `${actor} ⇢ ${preview.to}`;
   return `${actor} → ${actorName(preview.to)}`;
 }
 
-function style(styleFn: ((text: string) => string) | undefined, text: string): string {
+function style(
+  styleFn: ((text: string) => string) | undefined,
+  text: string,
+): string {
   return styleFn ? styleFn(text) : text;
 }
 
@@ -248,57 +349,47 @@ function previewText(preview: ActorInspectorPreview): string {
   return preview.summary || preview.body_preview || "-";
 }
 
-function detailText(preview: ActorInspectorPreview): string {
-  return preview.body_preview || preview.summary || "-";
-}
-
-function stripAnsi(value: string): string {
-  return value.replaceAll(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
-}
-
-function charDisplayWidth(char: string): number {
-  const code = char.codePointAt(0) ?? 0;
-  if (code === 0) return 0;
-  if (code < 32 || (code >= 0x7f && code < 0xa0)) return 0;
-  if (
-    code >= 0x1100 &&
-    (code <= 0x115f ||
-      code === 0x2329 ||
-      code === 0x232a ||
-      (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
-      (code >= 0xac00 && code <= 0xd7a3) ||
-      (code >= 0xf900 && code <= 0xfaff) ||
-      (code >= 0xfe10 && code <= 0xfe19) ||
-      (code >= 0xfe30 && code <= 0xfe6f) ||
-      (code >= 0xff00 && code <= 0xff60) ||
-      (code >= 0xffe0 && code <= 0xffe6) ||
-      (code >= 0x1f300 && code <= 0x1faff))
-  ) return 2;
-  return 1;
+function propertyValue(value: unknown): string {
+  if (value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
 }
 
 function displayWidth(value: string): number {
-  return Array.from(stripAnsi(value)).reduce((sum, char) => sum + charDisplayWidth(char), 0);
+  return visibleWidth(value);
 }
 
+const lineSegmenter = new Intl.Segmenter();
+
 function boundedLine(value: string, width: number): string {
-  if (displayWidth(value) <= width) return value;
-  if (width <= 1) return "";
+  if (width <= 0) return "";
+  if (visibleWidth(value) <= width) return value;
+  const ellipsis = "…";
+  const ellipsisWidth = visibleWidth(ellipsis);
+  if (width <= ellipsisWidth) return ellipsis.slice(0, width);
   let output = "";
   let used = 0;
-  for (const char of Array.from(value)) {
-    const charWidth = charDisplayWidth(char);
-    if (used + charWidth > width - 2) break;
-    output += char;
-    used += charWidth;
+  const maxTextWidth = width - ellipsisWidth;
+  for (const { segment } of lineSegmenter.segment(value)) {
+    const segmentWidth = visibleWidth(segment);
+    if (used + segmentWidth > maxTextWidth) break;
+    output += segment;
+    used += segmentWidth;
   }
-  return `${output}… `;
+  return `${output}${ellipsis}`;
 }
 
-function padLine(plain: string, rendered: string, width: number, styles: ActorInspectorWidgetStyle): string {
+function padLine(
+  plain: string,
+  rendered: string,
+  width: number,
+  styles: ActorInspectorWidgetStyle,
+): string {
   const boundedPlain = boundedLine(plain, width);
-  const visible = boundedPlain === plain ? rendered : style(styles.preview, boundedPlain);
-  const padding = Math.max(0, width - displayWidth(boundedPlain));
+  const visible =
+    boundedPlain === plain ? rendered : style(styles.preview, boundedPlain);
+  const padding = Math.max(0, width - visibleWidth(boundedPlain));
   return `${visible}${" ".repeat(padding)}`;
 }
 
@@ -313,15 +404,23 @@ function renderCompactInspectorEntry(
 ): string[] {
   const separator = "  ";
   const prefix = " ";
-  const contentWidth = Math.max(8, width - prefix.length);
+  const suffix = " ";
+  const contentWidth = Math.max(8, width - prefix.length - suffix.length);
   const sequence = String(preview.sequence ?? 0).padStart(sequenceWidth, " ");
-  const sequencePrefix = `${sequence}  `;
+  const sequencePrefix = `${sequence}${separator}`;
   const route = routeText(preview);
-  const routePadding = " ".repeat(Math.max(0, routeWidth - route.length));
-  const typePadding = " ".repeat(Math.max(0, typeWidth - preview.type.length));
+  const routePadding = " ".repeat(
+    Math.max(0, routeWidth - displayWidth(route)),
+  );
+  const typePadding = " ".repeat(
+    Math.max(0, typeWidth - displayWidth(preview.type)),
+  );
   const headline = previewText(preview);
   const lead = `${sequencePrefix}${route}${routePadding}${separator}${preview.type}${typePadding}${separator}`;
-  const visibleHeadline = boundedLine(headline, Math.max(0, contentWidth - lead.length));
+  const visibleHeadline = boundedLine(
+    headline,
+    Math.max(0, contentWidth - displayWidth(lead)),
+  );
   const plain = `${lead}${visibleHeadline}`;
   const rendered = [
     style(styles.muted, sequencePrefix),
@@ -333,57 +432,188 @@ function renderCompactInspectorEntry(
     separator,
     style(styles.preview, visibleHeadline),
   ].join("");
-  const line = `${prefix}${padLine(plain, rendered, contentWidth, styles)}`;
+  const line = `${prefix}${padLine(plain, rendered, contentWidth, styles)}${suffix}`;
   if (stripe && styles.stripe) return [styles.stripe(line)];
   if (!stripe && styles.stripeAlt) return [styles.stripeAlt(line)];
   return [line];
 }
 
-function renderVerboseInspectorEntry(
+function renderInspectorEntry(
   preview: ActorInspectorPreview,
   width: number,
   sequenceWidth: number,
-  labelWidth: number,
+  routeWidth: number,
+  typeWidth: number,
+  summaryWidth: number,
   styles: ActorInspectorWidgetStyle,
   stripe: boolean,
 ): string[] {
   const separator = "  ";
   const prefix = " ";
-  const contentWidth = Math.max(8, width - prefix.length);
+  const suffix = " ";
+  const contentWidth = Math.max(8, width - prefix.length - suffix.length);
   const sequence = String(preview.sequence ?? 0).padStart(sequenceWidth, " ");
-  const sequencePrefix = `${sequence}  `;
-  const detailSequencePrefix = `${" ".repeat(sequenceWidth)}  `;
+  const sequencePrefix = `${sequence}${separator}`;
   const route = routeText(preview);
-  const routePadding = " ".repeat(Math.max(0, labelWidth - route.length));
-  const typePadding = " ".repeat(Math.max(0, labelWidth - preview.type.length));
-  const headline = previewText(preview);
-  const detail = detailText(preview);
-  const headerLead = `${sequencePrefix}${route}${routePadding}${separator}`;
-  const detailLead = `${detailSequencePrefix}${preview.type}${typePadding}${separator}`;
-  const visibleHeadline = boundedLine(headline, Math.max(0, contentWidth - headerLead.length));
-  const visibleDetail = boundedLine(detail, Math.max(0, contentWidth - detailLead.length));
-  const headerPlain = `${headerLead}${visibleHeadline}`;
-  const detailPlain = `${detailLead}${visibleDetail}`;
-  const header = [
+  const type = preview.type;
+  const summary = preview.summary?.trim() ?? "";
+  const body = preview.body_preview?.trim() || (!summary ? previewText(preview) : "-");
+  const visibleRoute = boundedLine(route, routeWidth);
+  const visibleType = boundedLine(type, typeWidth);
+  const boundedRoutePadding = " ".repeat(Math.max(0, routeWidth - displayWidth(visibleRoute)));
+  const boundedTypePadding = " ".repeat(Math.max(0, typeWidth - displayWidth(visibleType)));
+  const leadParts = [
     style(styles.muted, sequencePrefix),
-    style(styles.target, route),
-    routePadding,
+    style(styles.target, visibleRoute),
+    boundedRoutePadding,
     separator,
-    style(styles.preview, visibleHeadline),
-  ].join("");
-  const detailLine = [
-    style(styles.muted, detailSequencePrefix),
-    style(styles.type, preview.type),
-    typePadding,
+    style(styles.type, visibleType),
+    boundedTypePadding,
     separator,
-    style(styles.preview, visibleDetail),
-  ].join("");
-  const lines = [
-    `${prefix}${padLine(headerPlain, header, contentWidth, styles)}`,
-    `${prefix}${padLine(detailPlain, detailLine, contentWidth, styles)}`,
   ];
-  if (stripe && styles.stripe) return lines.map((line) => styles.stripe?.(line) ?? line);
-  if (!stripe && styles.stripeAlt) return lines.map((line) => styles.stripeAlt?.(line) ?? line);
+  let lead = `${sequencePrefix}${visibleRoute}${boundedRoutePadding}${separator}${visibleType}${boundedTypePadding}${separator}`;
+  if (summary) {
+    const visibleSummary = boundedLine(summary, summaryWidth);
+    const summaryPadding = " ".repeat(Math.max(0, summaryWidth - displayWidth(visibleSummary)));
+    lead += `${visibleSummary}${summaryPadding}${separator}`;
+    leadParts.push(style(styles.preview, visibleSummary), summaryPadding, separator);
+  }
+  const visibleBody = boundedLine(body, Math.max(0, contentWidth - displayWidth(lead)));
+  const plain = `${lead}${visibleBody}`;
+  const rendered = `${leadParts.join("")}${style(styles.preview, visibleBody)}`;
+  const line = `${prefix}${padLine(plain, rendered, contentWidth, styles)}${suffix}`;
+  if (stripe && styles.stripe) return [styles.stripe(line)];
+  if (!stripe && styles.stripeAlt) return [styles.stripeAlt(line)];
+  return [line];
+}
+
+export function readActorInspectorRoster(
+  stateRoot = Paths.getRunStateRoot(),
+  run: string,
+  room = "main",
+): ActorInspectorRosterMember[] {
+  const stateDir = path.join(stateRoot, run);
+  const roster = readRoomRosterRecords(stateDir, room);
+  return Object.entries(roster).map(([address, member]) => ({
+    address,
+    ...(memberDisplay(address, member)
+      ? { display: memberDisplay(address, member) }
+      : {}),
+    ...(typeof member.role === "string" ? { role: member.role } : {}),
+    ...(typeof member.status === "string" ? { status: member.status } : {}),
+  }));
+}
+
+function rosterRoleText(role: string | undefined): string | undefined {
+  const cleaned = role?.replaceAll(/\s*\([^)]*\)\s*$/g, "").trim().toLowerCase();
+  if (!cleaned || cleaned === "actor") return undefined;
+  return cleaned.replaceAll(/\s+/g, "-");
+}
+
+function rosterMemberText(member: ActorInspectorRosterMember): string {
+  const name = member.display || actorName(member.address);
+  const role = rosterRoleText(member.role);
+  return role ? `${role}/${name}` : name;
+}
+
+function isRosterMemberActive(member: ActorInspectorRosterMember): boolean {
+  const status = member.status?.trim().toLowerCase();
+  return !status || status === "present" || status === "active" || status === "running";
+}
+
+export function renderInspectorRosterLine(
+  members: ActorInspectorRosterMember[],
+  width = 80,
+  styles: ActorInspectorWidgetStyle = {},
+): string | undefined {
+  return renderInspectorRosterPanel(members, width, styles)?.[0];
+}
+
+export function renderInspectorRosterPanel(
+  members: ActorInspectorRosterMember[],
+  width = 80,
+  styles: ActorInspectorWidgetStyle = {},
+): string[] | undefined {
+  if (members.length === 0) return undefined;
+  const safeWidth = Math.max(1, width);
+  const innerWidth = Math.max(1, safeWidth - 2);
+  const prefix = `roster ${members.length}: `;
+  const tokens = members.map((member) => ({
+    active: isRosterMemberActive(member),
+    text: rosterMemberText(member),
+  }));
+  const lines: string[] = [];
+  let plain = prefix;
+  let rendered = style(styles.muted, prefix);
+  const flush = () => {
+    const visible = boundedLine(plain, innerWidth);
+    const line = visible === plain ? rendered : style(styles.muted, visible);
+    lines.push(` ${line}${" ".repeat(Math.max(0, innerWidth - displayWidth(visible)))} `);
+  };
+  for (const token of tokens) {
+    const separator = plain === prefix ? "" : ", ";
+    const nextPlain = `${plain}${separator}${token.text}`;
+    const renderedToken = style(token.active ? styles.target : styles.muted, token.text);
+    if (plain !== prefix && displayWidth(nextPlain) > innerWidth) {
+      flush();
+      plain = `  ${token.text}`;
+      rendered = `${style(styles.muted, "  ")}${renderedToken}`;
+      continue;
+    }
+    plain = nextPlain;
+    rendered = `${rendered}${style(styles.muted, separator)}${renderedToken}`;
+  }
+  flush();
+  return lines;
+}
+
+export function renderInspectorItemView(
+  previews: ActorInspectorPreview[],
+  width = 80,
+  styles: ActorInspectorWidgetStyle = {},
+  options: ActorInspectorItemViewOptions,
+): string[] | undefined {
+  const preview = previews.find((item) => item.sequence === options.sequence);
+  if (!preview) return undefined;
+  const safeWidth = Math.max(1, width);
+  const orderedKeys = [
+    "channel",
+    "run",
+    "from",
+    "from_display",
+    "to",
+    "type",
+    "summary",
+    "body_preview",
+    "timestamp",
+    "stripe",
+  ] as const;
+  const entries = orderedKeys
+    .filter((key) => preview[key] !== undefined)
+    .map((key) => [key, propertyValue(preview[key])] as const);
+  const keyWidth = Math.max(1, ...entries.map(([key]) => displayWidth(key)));
+  const sequenceText = String(preview.sequence ?? options.sequence);
+  const sequencePadding = " ".repeat(Math.max(0, keyWidth - displayWidth(sequenceText)));
+  const headerSeparator = "  ";
+  const route = routeText(preview);
+  const visibleRoute = boundedLine(
+    route,
+    Math.max(0, safeWidth - keyWidth - headerSeparator.length),
+  );
+  const headerPlain = `${sequenceText}${sequencePadding}${headerSeparator}${visibleRoute}`;
+  const header = `${style(styles.muted, sequenceText)}${sequencePadding}${headerSeparator}${style(styles.target, visibleRoute)}`;
+  const headerPadding = Math.max(0, safeWidth - visibleWidth(headerPlain));
+  const lines = [`${header}${" ".repeat(headerPadding)}`, ""];
+  for (const [key, value] of entries) {
+    const keyPadding = " ".repeat(Math.max(0, keyWidth - displayWidth(key)));
+    const separator = "  ";
+    const valueWidth = Math.max(0, safeWidth - keyWidth - separator.length);
+    const visibleValue = boundedLine(value, valueWidth);
+    const plain = `${key}${keyPadding}${separator}${visibleValue}`;
+    const rendered = `${style(styles.muted, key)}${keyPadding}${separator}${style(styles.preview, visibleValue)}`;
+    const padding = Math.max(0, safeWidth - visibleWidth(plain));
+    lines.push(`${rendered}${" ".repeat(padding)}`);
+  }
   return lines;
 }
 
@@ -395,32 +625,58 @@ export function renderInspectorWidget(
 ): string[] | undefined {
   if (previews.length === 0) return undefined;
   const safeWidth = Math.max(1, width);
-  const verbosity = options.verbosity ?? "verbose";
-  const visibleLimit = verbosity === "compact" ? 12 : 6;
-  const visible = previews
-    .map((preview, index) => ({
-      preview: { ...preview, sequence: preview.sequence ?? index + 1 },
-      stripe: preview.stripe ?? index % 2 === 0,
-    }))
-    .slice(-visibleLimit);
+  void options;
+  const visible = previews.map((preview, index) => ({
+    preview: { ...preview, sequence: preview.sequence ?? index + 1 },
+    stripe: preview.stripe ?? index % 2 === 1,
+  }));
   const sequenceWidth = Math.max(
     1,
     ...visible.map(({ preview }) => String(preview.sequence ?? 0).length),
   );
   const lines: string[] = [];
-  if (verbosity === "compact") {
-    const routeWidth = Math.max(...visible.map(({ preview }) => routeText(preview).length));
-    const typeWidth = Math.max(...visible.map(({ preview }) => preview.type.length));
-    for (const { preview, stripe } of visible) {
-      lines.push(...renderCompactInspectorEntry(preview, safeWidth, sequenceWidth, routeWidth, typeWidth, styles, stripe));
-    }
-    return lines;
-  }
-  const labelWidth = Math.max(
-    ...visible.flatMap(({ preview }) => [routeText(preview).length, preview.type.length]),
+  const separatorWidth = 2;
+  const sequencePrefixWidth = sequenceWidth + separatorWidth;
+  const fixedSeparatorsWidth = separatorWidth * 3;
+  const availableForColumns = Math.max(
+    0,
+    safeWidth - 1 - sequencePrefixWidth - fixedSeparatorsWidth,
+  );
+  const naturalRouteWidth = Math.max(
+    ...visible.map(({ preview }) => displayWidth(routeText(preview))),
+  );
+  const naturalTypeWidth = Math.max(
+    ...visible.map(({ preview }) => displayWidth(preview.type)),
   );
+  const routeWidth = Math.min(
+    naturalRouteWidth,
+    Math.max(4, Math.floor(availableForColumns * 0.35)),
+  );
+  const typeWidth = Math.min(
+    naturalTypeWidth,
+    Math.max(4, Math.floor(availableForColumns * 0.25)),
+  );
+  const messageWidth = Math.max(0, availableForColumns - routeWidth - typeWidth);
+  const summaryWidths = visible
+    .map(({ preview }) => preview.summary?.trim())
+    .filter((summary): summary is string => Boolean(summary))
+    .map((summary) => displayWidth(summary));
+  const summaryWidth = summaryWidths.length
+    ? Math.min(Math.max(...summaryWidths), Math.max(1, Math.floor(messageWidth * 0.5)))
+    : 0;
   for (const { preview, stripe } of visible) {
-    lines.push(...renderVerboseInspectorEntry(preview, safeWidth, sequenceWidth, labelWidth, styles, stripe));
+    lines.push(
+      ...renderInspectorEntry(
+        preview,
+        safeWidth,
+        sequenceWidth,
+        routeWidth,
+        typeWidth,
+        summaryWidth,
+        styles,
+        stripe,
+      ),
+    );
   }
   return lines;
 }