Align coalesced lane member labels and cap lane memory

A lane hydrated without member labels paired later answers to the
wrong member; backfilled placeholders keep ids and labels aligned,
and both arrays now share the run cap instead of growing unbounded.

Author: TheGreatAxios

src/tui/tool-rows.test.ts

@@ -242,7 +242,7 @@ describe("a run of identical calls", () => {
     expect(rows[0]?.outstanding).toBe(0);
   });
 
-  test("a lane keeps every member id while the count climbs", () => {
+  test("a lane caps member ids and labels together at the run cap", () => {
     const rows: StreamRow[] = [];
     for (let i = 1; i <= 33; i++) {
       pushToolCall(rows, {
@@ -253,7 +253,10 @@ describe("a run of identical calls", () => {
     }
     expect(rows.length).toBe(1);
     expect(rows[0]?.callCount).toBe(33);
-    expect(rows[0]?.memberIds?.length).toBe(33);
+    // The lane's memory is bounded alongside the detail cap, oldest-first
+    // like the answers — and both arrays together, never one alone.
+    expect(rows[0]?.memberIds?.length).toBe(30);
+    expect(rows[0]?.memberLabels?.length).toBe(30);
     expect(rows[0]?.memberIds?.[0]).toBe("c1");
     expect(pendingCallIndex(rows, "grep", "c33")).toBe(0);
     expect(pendingCallIndex(rows, "grep", "c1")).toBe(0);
@@ -274,16 +277,24 @@ describe("a run of identical calls", () => {
     expect(rows.length).toBe(1);
     expect(rows[0]?.pending).toBe(true);
     expect(rows[0]?.outstanding).toBe(32);
-    for (let i = 2; i <= 33; i++) {
+    // Members past the run cap kept no id on the lane, so their answers
+    // cannot pair back to it — except the newest, found by the lane's own id.
+    for (let i = 2; i <= 30; i++) {
       pushToolResult(rows, {
         name: "grep",
         content: `r${i}`,
         callId: `c${i}`,
       });
     }
+    pushToolResult(rows, { name: "grep", content: "r33", callId: "c33" });
     expect(rows.length).toBe(1);
-    expect(rows[0]?.pending).toBeUndefined();
-    expect(rows[0]?.outstanding).toBe(0);
+    expect(rows[0]?.pending).toBe(true);
+    expect(rows[0]?.outstanding).toBe(2);
+    pushToolResult(rows, { name: "grep", content: "r31", callId: "c31" });
+    pushToolResult(rows, { name: "grep", content: "r32", callId: "c32" });
+    expect(rows.length).toBe(3);
+    expect(rows[0]?.pending).toBe(true);
+    expect(rows[0]?.outstanding).toBe(2);
   });
 
   test("a different tool breaks the lane", () => {
@@ -370,6 +381,70 @@ describe("a run of identical calls", () => {
     ]);
   });
 
+  test("four members each name their own target", () => {
+    const rows: StreamRow[] = [];
+    const issues = ["CL-7386", "CL-7390", "CL-7399", "CL-7401"];
+    issues.forEach((issueId, i) => {
+      pushToolCall(rows, {
+        name: "mcp__linear__save_comment",
+        arguments: JSON.stringify({ issueId, body: `note ${i}` }),
+        callId: `m${i}`,
+      });
+    });
+    issues.forEach((_, i) => {
+      pushToolResult(rows, {
+        name: "mcp__linear__save_comment",
+        content: "",
+        callId: `m${i}`,
+      });
+    });
+    expect(rows.length).toBe(1);
+    expect(rows[0]?.memberLabels).toEqual(issues);
+    expect(runLines(rows[0])).toEqual(issues.map((id) => `${id} — answered`));
+  });
+
+  test("a pre-PR lane with ids but no labels coalesces with aligned placeholders", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7386", body: "first" }),
+      callId: "m1",
+    });
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7390", body: "second" }),
+      callId: "m2",
+    });
+    // Lanes persisted before per-call labels carry memberIds without
+    // memberLabels; only the tail's own label is still recoverable.
+    const { memberLabels: _dropped, ...legacy } = defined(rows[0]);
+    rows[0] = legacy;
+    pushToolCall(rows, {
+      name: "mcp__linear__save_comment",
+      arguments: JSON.stringify({ issueId: "CL-7399", body: "third" }),
+      callId: "m3",
+    });
+    expect(rows[0]?.memberIds).toEqual(["m1", "m2", "m3"]);
+    expect(rows[0]?.memberLabels).toEqual(["", "CL-7390", "CL-7399"]);
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "",
+      callId: "m2",
+    });
+    // Without the placeholder backfill the second result would read the
+    // third member's label.
+    expect(runLines(rows[0])).toEqual(["CL-7390 — answered"]);
+    pushToolResult(rows, {
+      name: "mcp__linear__save_comment",
+      content: "",
+      callId: "m3",
+    });
+    expect(runLines(rows[0])).toEqual([
+      "CL-7390 — answered",
+      "CL-7399 — answered",
+    ]);
+  });
+
   test("a member settled before the lane keeps the call's label, not the payload's", () => {
     const rows: StreamRow[] = [];
     pushToolCall(rows, {

src/tui/tool-rows.ts

@@ -343,16 +343,26 @@ function laneMembers(
   tail: StreamRow,
   next: StreamRow,
 ): { ids: string[]; labels: string[] } {
-  const ids = [
-    ...(tail.memberIds ?? (tail.callId !== undefined ? [tail.callId] : [])),
-    ...(next.callId !== undefined ? [next.callId] : []),
-  ];
+  const tailIds =
+    tail.memberIds ?? (tail.callId !== undefined ? [tail.callId] : []);
+  // A lane hydrated from pre-PR history carries memberIds without
+  // memberLabels. Backfill placeholders so the two arrays stay aligned —
+  // only the tail's own label is still recoverable; earlier members read as
+  // bare outcomes until their answers arrive.
+  const tailLabels =
+    tail.memberLabels ??
+    tailIds.map((id) => (id === tail.callId ? laneMemberLabel(tail) : ""));
+  const ids = [...tailIds, ...(next.callId !== undefined ? [next.callId] : [])];
   const labels = [
-    ...(tail.memberLabels ??
-      (tail.callId !== undefined ? [laneMemberLabel(tail)] : [])),
+    ...tailLabels,
     ...(next.callId !== undefined ? [laneMemberLabel(next)] : []),
   ];
-  return { ids, labels };
+  // Bound the lane's memory alongside the detail cap, oldest-first like the
+  // answers. Both arrays are sliced together so they never come unaligned.
+  return {
+    ids: ids.slice(0, MAX_RUN_LINES),
+    labels: labels.slice(0, MAX_RUN_LINES),
+  };
 }
 
 /**