fix(tui): drop the preamble every Dynamic Workflow task repeats

`prompt_template` is optional, so a caller may pass a whole prompt as
each item. Every agent row then opened with the same paragraph and the
task column clipped inside it, leaving six rows that named nothing.

Measure the shared head across every member, cut it at the last shared
word boundary, and mark the elision with a single column. The elision is
all-or-nothing and skipped for a short head, so a column never means two
different things and a mark never costs more than it frees.

Author: elkaix

.changeset/dynamic-workflow-shared-task-preamble.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Drop the preamble every Dynamic Workflow task repeats so each agent row shows the part that names it.

apps/pythinker-code/src/tui/components/messages/dynamic-workflow-mission-control.ts

@@ -11,6 +11,8 @@ import { shimmerText } from '#/tui/utils/shimmer';
 const RESUMED_ITEM_LABEL = '(resumed)';
 /** Divider between the cells that share a member row's free space. */
 const MEMBER_SEPARATOR = ' · ';
+/** Marks a task cell whose shared preamble was dropped. One column wide. */
+const TASK_ELISION_MARK = '…';
 const ORCHESTRATING_LABEL = 'Orchestrating';
 const FINALIZING_LABEL = 'Finalizing';
 // Pad to the wider live label so the suffix column never shifts between them.
@@ -440,8 +442,11 @@ export class DynamicWorkflowMissionControlComponent implements Component {
       const needsMore = members.length > slots;
       const memberSlots = needsMore && slots >= 2 ? slots - 1 : slots;
       const visibleMembers = members.slice(0, Math.max(0, memberSlots));
+      // Measured across every member, not the visible ones: a prefix that came
+      // and went as rows scrolled would rewrite the task column under the eye.
+      const sharedPrefix = sharedTaskPrefix(members);
       for (const member of visibleMembers) {
-        lines.push(this.renderMember(member, width, nowMs));
+        lines.push(this.renderMember(member, width, nowMs, sharedPrefix));
       }
       const hidden = members.length - visibleMembers.length;
       if (hidden > 0 && lines.length < rowBudget) {
@@ -567,7 +572,12 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     return truncateToWidth(currentTheme.fg('textDim', header), width);
   }
 
-  private renderMember(member: DynamicWorkflowMember, width: number, nowMs: number): string {
+  private renderMember(
+    member: DynamicWorkflowMember,
+    width: number,
+    nowMs: number,
+    sharedPrefix: string,
+  ): string {
     const id = currentTheme.fg('primary', String(member.index).padStart(3, '0'));
     // All running rows share the workflow's clock, so they spin in step instead
     // of drifting apart by whenever each agent happened to start.
@@ -585,6 +595,11 @@ export class DynamicWorkflowMissionControlComponent implements Component {
       ? `${id}  ${workColumn}  ${stateColumn}  `
       : `${id} ${padToWidth(state, 6)} `;
     const task = member.item || 'Delegated agent';
+    // The elision is display-only: the dedup below still compares whole items,
+    // so a streamed line that merely repeats the task is still suppressed.
+    const shownTask = sharedPrefix.length > 0 && member.item.startsWith(sharedPrefix)
+      ? `${TASK_ELISION_MARK}${member.item.slice(sharedPrefix.length)}`
+      : task;
     const latest = member.latest.length > 0 && member.latest !== task ? member.latest : undefined;
     const detail = member.phase === 'suspended' || isTerminalPhase(member.phase)
       ? member.statusDetail ?? latest
@@ -613,15 +628,15 @@ export class DynamicWorkflowMissionControlComponent implements Component {
       Math.floor(rest * DYNAMIC_WORKFLOW_RENDERING.memberTaskShare),
     );
     const detailBudget = showWork && detail !== undefined && detail.length > 0
-      ? rest - Math.min(visibleWidth(task), taskCap) - MEMBER_SEPARATOR.length
+      ? rest - Math.min(visibleWidth(shownTask), taskCap) - MEMBER_SEPARATOR.length
       : 0;
     const detailPart = detailBudget >= DYNAMIC_WORKFLOW_RENDERING.memberDetailMinWidth
       ? `${MEMBER_SEPARATOR}${truncateToWidth(currentTheme.fg('textDim', detail ?? ''), detailBudget)}`
       : '';
 
     // Whatever the detail did not take goes back to the task.
     const taskText = truncateToWidth(
-      currentTheme.fg('text', task),
+      currentTheme.fg('text', shownTask),
       Math.max(1, rest - visibleWidth(detailPart)),
     );
     return truncateToWidth(
@@ -1071,6 +1086,52 @@ function normalizeText(text: string | undefined): string {
   return text?.replaceAll(/\s+/g, ' ').trim() ?? '';
 }
 
+/**
+ * The preamble every task repeats, or `''` when dropping it would not help.
+ *
+ * `prompt_template` is optional, so a caller may pass a whole prompt as each
+ * item. Every row then opens with the same paragraph and the TASK column clips
+ * inside it — six rows reading `You are auditing the pythinker-code mono...`
+ * name nothing. Dropping the shared head once puts the tail that identifies the
+ * row back on screen.
+ *
+ * All-or-nothing on purpose: eliding a prefix that only some rows carry would
+ * make two cells at the same column mean different things.
+ */
+function sharedTaskPrefix(members: readonly DynamicWorkflowMember[]): string {
+  const items = members.map((member) => member.item).filter((item) => item.length > 0);
+  const first = items[0];
+  if (first === undefined || items.length < 2) return '';
+
+  // Skips `first` against itself: that comparison can only return its own
+  // length, and it walks the whole string to say so on every animation frame.
+  let length = first.length;
+  for (const item of items.slice(1)) {
+    length = commonPrefixLength(first, item, length);
+    if (length === 0) return '';
+  }
+
+  // Cut at the last space inside the shared text. A cut mid-word reads as
+  // corruption, and a space is always a whole code unit, so ending there is
+  // also what keeps the slice off the middle of a surrogate pair.
+  //
+  // Backing off to before the last shared word is what leaves every row
+  // something after the mark: items are normalized, so none of them ends in a
+  // space, and the shortest one therefore still holds the word the cut skipped.
+  const boundary = first.lastIndexOf(' ', length - 1);
+  if (boundary < 0) return '';
+  const prefix = first.slice(0, boundary + 1);
+  if (visibleWidth(prefix) < DYNAMIC_WORKFLOW_RENDERING.memberTaskSharedPrefixMinWidth) return '';
+  return prefix;
+}
+
+function commonPrefixLength(left: string, right: string, limit: number): number {
+  const bound = Math.min(limit, left.length, right.length);
+  let index = 0;
+  while (index < bound && left[index] === right[index]) index += 1;
+  return index;
+}
+
 /**
  * The WORK cell: tool calls done, and how long this agent has been silent.
  *

apps/pythinker-code/src/tui/constant/rendering.ts

@@ -34,6 +34,12 @@ export const DYNAMIC_WORKFLOW_RENDERING = {
   memberTaskShare: 0.6,
   /** Below this the detail is dropped: a few clipped characters say nothing. */
   memberDetailMinWidth: 8,
+  /**
+   * Least shared task prefix worth eliding. A short prefix costs about as much
+   * to mark as it frees, so only a preamble long enough to have been clipping
+   * the part that names the row is dropped.
+   */
+  memberTaskSharedPrefixMinWidth: 16,
   /**
    * Upper bound on one buffered output line. A model may stream a single line
    * with no newline in it at all, so this is the only thing that stops the

apps/pythinker-code/test/tui/components/messages/dynamic-workflow-mission-control.test.ts

@@ -23,6 +23,9 @@ function renderText(component: DynamicWorkflowMissionControlComponent, width = 1
 /** The STATE cell of a running row: a grey braille spinner frame, then the label. */
 const RUNNING_CELL = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] RUN/u;
 
+/** Head of a task cell that lost the preamble every row shared. */
+const TASK_ELISION_MARK = '…';
+
 function memberLine(output: string, index: number): string {
   const id = String(index).padStart(3, '0');
   const line = output.split('\n').find(
@@ -772,6 +775,90 @@ describe('DynamicWorkflowMissionControlComponent', () => {
     expect(lines.join('\n')).not.toContain('Recent activity');
   });
 
+  it('drops the preamble every task repeats so the row keeps what names it', () => {
+    const preamble = 'You are auditing the pythinker-code monorepo at /Users/panda. Verify ';
+    const component = createComponent();
+    component.updateArgs({
+      items: [
+        `${preamble}the permission glob`,
+        `${preamble}the concurrency cap`,
+        `${preamble}the resume path`,
+      ],
+    });
+    component.markInputComplete();
+
+    const output = renderText(component, 100);
+    expect(output).not.toContain('You are auditing');
+    // Greedy on purpose: the shared `the ` goes with the rest of the preamble.
+    expect(memberLine(output, 1)).toContain('…permission glob');
+    expect(memberLine(output, 2)).toContain('…concurrency cap');
+    expect(memberLine(output, 3)).toContain('…resume path');
+
+    // The mark is one column wide, so it never pushes a row past the frame.
+    for (const width of [20, 40, 63, 64, 79, 80, 100, 150]) {
+      expect(component.render(width).every((line) => visibleWidth(line) <= width)).toBe(true);
+    }
+  });
+
+  it.each([
+    // Nothing shared: every row already names itself.
+    { name: 'no shared head', items: ['Audit the plan', 'Ship the release'] },
+    // Shared but short: the mark would cost about what the elision frees.
+    { name: 'a short shared head', items: ['Audit the plan', 'Audit the release'] },
+    // One row is the whole of what the other shares, and what is left over is
+    // one short word — below the floor, so the rows stay whole.
+    { name: 'a row that is the whole shared head', items: ['Audit the plan appendix', 'Audit the plan'] },
+    // A prefix with no space in it can only be cut mid-word.
+    { name: 'an unbroken shared head', items: ['aaaaaaaaaaaaaaaaaaaa-one', 'aaaaaaaaaaaaaaaaaaaa-two'] },
+  ])('keeps whole tasks when there is $name', ({ items }) => {
+    const component = createComponent();
+    component.updateArgs({ items });
+    component.markInputComplete();
+
+    const output = renderText(component, 200);
+    items.forEach((item, index) => {
+      expect(memberLine(output, index + 1)).toContain(item);
+      expect(memberLine(output, index + 1)).not.toContain(TASK_ELISION_MARK);
+    });
+  });
+
+  it('leaves a row whose whole task is the shared head with the word the cut skipped', () => {
+    const component = createComponent();
+    component.updateArgs({
+      items: [
+        'Audit the pythinker-code monorepo',
+        'Audit the pythinker-code monorepo plan',
+      ],
+    });
+    component.markInputComplete();
+
+    // The cut lands before `monorepo`, not after it, so the shorter row keeps a
+    // word rather than collapsing to the mark on its own.
+    const output = renderText(component, 100);
+    expect(memberLine(output, 1)).toContain('…monorepo');
+    expect(memberLine(output, 2)).toContain('…monorepo plan');
+    expect(output).not.toContain('Audit the pythinker-code');
+  });
+
+  it('holds the elision steady while rows are clipped away', () => {
+    const preamble = 'Audit the pythinker-code monorepo and report on ';
+    const items = ['the plan', 'the cap', 'the resume path', 'the glob'].map(
+      (tail) => `${preamble}${tail}`,
+    );
+    const full = createComponent();
+    full.updateArgs({ items });
+    full.markInputComplete();
+    // Two of the four rows are clipped, but the prefix is measured across every
+    // member, so the visible rows read exactly as they did before the clip.
+    const clipped = createComponent({ availableRows: () => 6 });
+    clipped.updateArgs({ items });
+    clipped.markInputComplete();
+
+    expect(memberLine(renderText(clipped, 100), 1))
+      .toBe(memberLine(renderText(full, 100), 1));
+    expect(memberLine(renderText(clipped, 100), 1)).toContain('…plan');
+  });
+
   it('keeps three workflow-relative activity entries with suspension and failure details', () => {
     vi.useFakeTimers();
     vi.setSystemTime(0);