Show per-call subjects in coalesced tool lanes

Author: TheGreatAxios

src/tui/stream.ts

@@ -163,6 +163,12 @@ export interface StreamRow {
    * newest call.
    */
   readonly memberIds?: readonly string[];
+  /**
+   * What each absorbed call was about, aligned with `memberIds` — a lane's
+   * expanded body lines are "member — outcome" pairs, not bare "answered",
+   * because four identical answers to four different calls say nothing.
+   */
+  readonly memberLabels?: readonly string[];
   /**
    * Most recent result's full text on a coalesced lane — the Alt+C copy
    * source. Single rows copy `text` as before.

src/tui/tool-rows.test.ts

@@ -333,6 +333,116 @@ describe("a run of identical calls", () => {
     expect(rows[0]?.outstanding).toBe(1);
     expect(rows[0]?.pending).toBe(true);
   });
+
+  const runLines = (row: StreamRow | undefined): string[] =>
+    (row?.detail ?? []).map((line) =>
+      line.map((segment) => segment.text).join(""),
+    );
+
+  test("each member line names the call's own target, not a bare answer", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7386", body: "looks good" }),
+      callId: "m1",
+    });
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7390", body: "done" }),
+      callId: "m2",
+    });
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "",
+      callId: "m1",
+    });
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "",
+      callId: "m2",
+    });
+    // An MCP call's painted summary is empty — the verb is the sentence — so
+    // the lane reads the identifying argument (the issue, not the body).
+    expect(rows[0]?.memberLabels).toEqual(["CL-7386", "CL-7390"]);
+    expect(runLines(rows[0])).toEqual([
+      "CL-7386 — answered",
+      "CL-7390 — answered",
+    ]);
+  });
+
+  test("a member settled before the lane keeps the call's label, not the payload's", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7386", body: "first" }),
+      callId: "m1",
+    });
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: '{"id":"comment-9"}',
+      callId: "m1",
+    });
+    // The merge replaced the row's args with the answer payload; the label
+    // must still name what the call acted on.
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7390", body: "second" }),
+      callId: "m2",
+    });
+    expect(rows[0]?.memberLabels).toEqual(["CL-7386", "CL-7390"]);
+    expect(runLines(rows[0])).toEqual(['CL-7386 — {"id":"comment-9"}']);
+  });
+
+  test("a failed member's line carries its target and the error", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-1", body: "x" }),
+      callId: "m1",
+    });
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-2", body: "y" }),
+      callId: "m2",
+    });
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "HTTP 401 unauthorized",
+      isError: true,
+      callId: "m1",
+    });
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "",
+      callId: "m2",
+    });
+    expect(runLines(rows[0])).toEqual([
+      "CL-1 — HTTP 401 unauthorized",
+      "CL-2 — answered",
+    ]);
+  });
+
+  test("member labels are one-line and bounded", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "mcp__granola__search",
+      arguments: JSON.stringify({
+        query: `  multi\n  line ${"q".repeat(100)}`,
+      }),
+      callId: "m1",
+    });
+    pushToolCall(rows, {
+      name: "mcp__granola__search",
+      arguments: JSON.stringify({ query: "b" }),
+      callId: "m2",
+    });
+    const labels = rows[0]?.memberLabels ?? [];
+    expect(labels.length).toBe(2);
+    expect(labels[0]?.length).toBeLessThanOrEqual(48);
+    expect(labels[0]).not.toContain("\n");
+    expect(labels[0]?.endsWith("…")).toBe(true);
+    expect(labels[1]).toBe("b");
+  });
 });
 
 describe("parallel calls to the same tool", () => {
@@ -969,8 +1079,7 @@ describe("lane paint", () => {
     const answers = (rows[0]?.detail ?? []).map((line) =>
       line.map((segment) => segment.text).join(""),
     );
-    expect(answers).not.toEqual(["answered", "answered"]);
-    expect(answers).toContain("a");
+    expect(answers).toEqual(["echo a — a", "echo b — b"]);
     expect(rows[0]?.resultText).toBe("b");
     expect(rows[0]?.previewLines).toEqual(["b"]);
   });

src/tui/tool-rows.ts

@@ -32,13 +32,109 @@ function runLine(text: string, fg: string = UI.text): StyledBodyLine {
 
 function appendRunLine(
   lines: readonly StyledBodyLine[],
-  text: string,
+  line: StyledBodyLine,
 ): readonly StyledBodyLine[] {
   if (lines.length > MAX_RUN_LINES) return lines;
   if (lines.length === MAX_RUN_LINES) {
     return [...lines, runLine("… more answers", UI.textDim)];
   }
-  return [...lines, runLine(text)];
+  return [...lines, line];
+}
+
+/**
+ * One member's line in a lane's expanded body: which call, then what it got.
+ * The label is dim so the outcome — the part that changes per member — reads
+ * first.
+ */
+function memberRunLine(label: string, outcome: string): StyledBodyLine {
+  if (label.length === 0) return runLine(outcome);
+  return [
+    { text: label, fg: UI.textDim },
+    { text: ` — ${outcome}`, fg: UI.text },
+  ];
+}
+
+/**
+ * Argument keys that name which object a call acted on, most-identifying
+ * first. Only consulted when the call's painted summary is empty — an MCP
+ * call's verb is already the whole sentence, so its subject lives in the
+ * arguments (the issue id on a save_comment, not the comment body).
+ */
+const LANE_MEMBER_KEYS = [
+  "issueId",
+  "issue",
+  "commentId",
+  "id",
+  "key",
+  "command",
+  "query",
+  "url",
+  "pattern",
+  "path",
+  "file_path",
+  "name",
+  "description",
+  "prompt",
+] as const;
+
+const LANE_MEMBER_SUBJECT_MAX = 48;
+
+function clipMemberSubject(value: string): string {
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length <= LANE_MEMBER_SUBJECT_MAX
+    ? oneLine
+    : `${oneLine.slice(0, LANE_MEMBER_SUBJECT_MAX - 1)}…`;
+}
+
+function memberArgs(raw: string): Record<string, unknown> | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  return parsed as Record<string, unknown>;
+}
+
+/** Which object a lane member acted on, read off its painted summary or args. */
+function laneMemberLabel(row: StreamRow): string {
+  // A settled row's label was recorded at merge time, while its arguments
+  // were still on the row — re-deriving now would read keys off the answer
+  // payload that replaced them.
+  if (row.callId !== undefined) {
+    const index = (row.memberIds ?? []).indexOf(row.callId);
+    const recorded = index >= 0 ? (row.memberLabels?.[index] ?? "") : "";
+    if (recorded.length > 0) return recorded;
+  }
+  const summary = row.summary?.trim() ?? "";
+  if (summary.length > 0) return clipMemberSubject(summary);
+  const args = memberArgs(row.text);
+  if (args !== null) {
+    for (const key of LANE_MEMBER_KEYS) {
+      const value = args[key];
+      if (typeof value === "string" && value.trim().length > 0) {
+        return clipMemberSubject(value);
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+    }
+    const first = Object.values(args).find(
+      (value) => typeof value === "string" && value.trim().length > 0,
+    );
+    if (typeof first === "string") return clipMemberSubject(first);
+  }
+  return row.verb ?? row.meta ?? row.toolName ?? "";
+}
+
+/** The label the result's call carried when the lane absorbed it, if known. */
+function memberLabelFor(call: StreamRow, result: StreamRow): string {
+  if (result.callId === undefined) return "";
+  const index = (call.memberIds ?? []).indexOf(result.callId);
+  return index >= 0 ? (call.memberLabels?.[index] ?? "") : "";
 }
 
 /** Longest an answer's own words may run before they belong behind the arrow. */
@@ -187,7 +283,10 @@ export function mergeToolRows(call: StreamRow, result: StreamRow): StreamRow {
       ...(remaining > 0 ? { pending: true } : {}),
       detail: appendRunLine(
         call.detail ?? [],
-        failed ? "call failed" : (addendum ?? "answered"),
+        memberRunLine(
+          memberLabelFor(call, result),
+          failed ? (addendum ?? "call failed") : (addendum ?? "answered"),
+        ),
       ),
     };
   }
@@ -196,6 +295,14 @@ export function mergeToolRows(call: StreamRow, result: StreamRow): StreamRow {
   const showsPayload = payload.length > 0 && payload !== base.stat;
   return {
     ...base,
+    // The merge is the last moment this call's own arguments are on the
+    // row — record who it was so a later repeat can name it in the lane.
+    ...(call.callId !== undefined
+      ? {
+          memberIds: [call.callId],
+          memberLabels: [laneMemberLabel(call)],
+        }
+      : {}),
     ...(result.structured !== undefined
       ? { structured: result.structured }
       : {}),
@@ -232,12 +339,20 @@ export function canCoalesceCall(
 
 /** Calls a lane remembers so a later result can still find this row. */
 
-function laneMembers(tail: StreamRow, next: StreamRow): string[] | undefined {
-  const members = [
+function laneMembers(
+  tail: StreamRow,
+  next: StreamRow,
+): { ids: string[]; labels: string[] } {
+  const ids = [
     ...(tail.memberIds ?? (tail.callId !== undefined ? [tail.callId] : [])),
     ...(next.callId !== undefined ? [next.callId] : []),
   ];
-  return members.length > 0 ? members : undefined;
+  const labels = [
+    ...(tail.memberLabels ??
+      (tail.callId !== undefined ? [laneMemberLabel(tail)] : [])),
+    ...(next.callId !== undefined ? [laneMemberLabel(next)] : []),
+  ];
+  return { ids, labels };
 }
 
 /**
@@ -252,7 +367,15 @@ export function coalesceCallRows(tail: StreamRow, next: StreamRow): StreamRow {
       ? (tail.detail ?? [])
       : tail.pending === true
         ? []
-        : appendRunLine([], tail.stat ?? "answered");
+        : appendRunLine(
+            [],
+            memberRunLine(
+              laneMemberLabel(tail),
+              tail.failed === true
+                ? (tail.stat ?? "call failed")
+                : (tail.stat ?? "answered"),
+            ),
+          );
   // A run's body is the answers it collected; the argument view, table and diff
   // belong to a single call, which this row no longer stands alone for.
   const {
@@ -262,11 +385,12 @@ export function coalesceCallRows(tail: StreamRow, next: StreamRow): StreamRow {
     ...call
   } = next;
   const inFlight = tail.outstanding ?? (tail.pending === true ? 1 : 0);
-  const memberIds = laneMembers(tail, next);
+  const members = laneMembers(tail, next);
   return {
     ...call,
     callCount: (tail.callCount ?? 1) + 1,
-    ...(memberIds !== undefined ? { memberIds } : {}),
+    ...(members.ids.length > 0 ? { memberIds: members.ids } : {}),
+    ...(members.labels.length > 0 ? { memberLabels: members.labels } : {}),
     coalesced: true,
     outstanding: inFlight + 1,
     ...(tail.failed === true ? { failed: true } : {}),