fix: keep Dynamic Workflow progress moving instead of pinning at 90%

Per-agent progress previously jumped through fixed stage values and
capped at 90 for the entire finalizing stream. Each model delta now
creeps toward the stage ceiling with a minimum step, the aggregate
line shows Finalizing once every delegated agent is terminal but the
result has not arrived, and narrow-width member rows pad the state
token so the task column no longer shifts between phases.

Author: elkaix

.changeset/dynamic-workflow-progress-stall.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Fix Dynamic Workflow progress sticking at 90% during long streaming, show a Finalizing state once all delegated agents finish, and fix member row alignment at narrow widths.

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

@@ -9,7 +9,12 @@ import { shimmerText } from '#/tui/utils/shimmer';
 
 const RESUMED_ITEM_LABEL = '(resumed)';
 const ORCHESTRATING_LABEL = 'Orchestrating';
-const ORCHESTRATING_LABEL_WIDTH = visibleWidth(ORCHESTRATING_LABEL);
+const FINALIZING_LABEL = 'Finalizing';
+// Pad to the wider live label so the suffix column never shifts between them.
+const LIVE_LABEL_WIDTH = Math.max(
+  visibleWidth(ORCHESTRATING_LABEL),
+  visibleWidth(FINALIZING_LABEL),
+);
 const MAX_DYNAMIC_WORKFLOW_MEMBERS = 128;
 
 /** Lifecycle state of one delegated agent row, driven only by observed events. */
@@ -41,7 +46,9 @@ export interface DynamicWorkflowMember {
   endedAtMs?: number;
   /**
    * Observed-stage progress heuristic (0-100): the protocol emits no per-task
-   * percentage, so stages step through fixed values and never predict time.
+   * percentage, so stage floors map to observed events and streamed deltas
+   * creep asymptotically toward a ceiling. May hold fractional values
+   * internally; display floors it. Only a terminal event reaches 100.
    */
   progressPercent: number;
 }
@@ -249,12 +256,27 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     if (member === undefined || isTerminalPhase(member.phase) || input.delta.length === 0) return;
     this.markStarted(input.agentId);
     const recordActivity = input.delta.includes('\n') || member.latest.length === 0;
-    // Text after a tool call counts as finalizing; earlier text is mid-work output.
+    // Text after a tool call counts as finalizing; earlier text is mid-work
+    // output. Each delta creeps toward the stage ceiling — with a minimum
+    // step so long streams keep visibly moving — without claiming completion.
+    const percent = member.progressPercent;
+    const {
+      toolActivityProgress,
+      finalizingCreepCeiling,
+      modelActivityProgress,
+      midworkCreepCeiling,
+      progressCreepRate,
+      progressCreepMinStep,
+    } = DYNAMIC_WORKFLOW_RENDERING;
+    const creepToward = (ceiling: number): number => Math.min(
+      ceiling,
+      percent + Math.max(progressCreepMinStep, (ceiling - percent) * progressCreepRate),
+    );
     this.advanceMemberProgress(
       member,
-      member.progressPercent >= DYNAMIC_WORKFLOW_RENDERING.toolActivityProgress
-        ? DYNAMIC_WORKFLOW_RENDERING.finalizingProgress
-        : DYNAMIC_WORKFLOW_RENDERING.modelActivityProgress,
+      percent >= toolActivityProgress
+        ? creepToward(finalizingCreepCeiling)
+        : Math.max(modelActivityProgress, creepToward(midworkCreepCeiling)),
     );
     const latest = latestNonEmptyLine(`${member.latest}${input.delta}`);
     this.setLatest(member, latest, recordActivity);
@@ -465,21 +487,30 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     const loader = terminal
       ? currentTheme.fg(requestPhaseColor(this.model.requestPhase), requestPhaseSymbol(this.model.requestPhase))
       : this.activitySpinnerText?.() ?? currentTheme.fg('primary', '●');
+    const aggregateMembers = this.aggregateMembers();
+    // All spawned agents are done but the tool result has not arrived yet:
+    // the label says so instead of pretending orchestration is still active.
+    // Every member counts — including out-of-band rows beyond knownTotal —
+    // so the label never claims "done" above a row still marked running.
+    const finalizing = !terminal &&
+      this.model.knownTotal !== undefined &&
+      this.model.knownTotal > 0 &&
+      aggregateMembers.length === this.model.knownTotal &&
+      this.model.members.every((member) => isTerminalPhase(member.phase));
     // The live label shimmers from elapsed time; no timer is created because
     // the host owns animation and only re-renders this block.
     const label = terminal
       ? currentTheme.fg('text', requestPhaseLabel(this.model.requestPhase))
-      : shimmerText(ORCHESTRATING_LABEL, {
+      : shimmerText(finalizing ? FINALIZING_LABEL : ORCHESTRATING_LABEL, {
           baseToken: 'text',
           shimmerToken: 'primaryShimmer',
           frame: Math.floor(
             Math.max(0, nowMs - this.model.startedAtMs) / BRAILLE_SPINNER_INTERVAL_MS,
           ),
           windowSize: 4,
         });
-    const paddedLabel = padToWidth(label, ORCHESTRATING_LABEL_WIDTH);
+    const paddedLabel = padToWidth(label, LIVE_LABEL_WIDTH);
     const prefix = `${loader} ${paddedLabel}`;
-    const aggregateMembers = this.aggregateMembers();
     const completed = aggregateMembers.filter((member) => member.phase === 'completed').length;
     const failed = aggregateMembers.filter((member) => member.phase === 'failed').length;
     const cancelled = aggregateMembers.filter((member) => member.phase === 'cancelled').length;
@@ -516,7 +547,7 @@ export class DynamicWorkflowMissionControlComponent implements Component {
         padToWidth('STATE', 6),
         'TASK',
       ].join('  ')
-      : 'ID   STATE    TASK';
+      : `${padToWidth('ID', 3)} ${padToWidth('STATE', 6)} TASK`;
     return truncateToWidth(currentTheme.fg('textDim', header), width);
   }
 
@@ -527,7 +558,7 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     const showProgress = width >= DYNAMIC_WORKFLOW_RENDERING.memberProgressMinWidth;
     const progress = `${renderProgressCube(progressPercent)} ${currentTheme.fg(
       'textMuted',
-      `${String(progressPercent).padStart(3, ' ')}%`,
+      `${String(Math.floor(progressPercent)).padStart(3, ' ')}%`,
     )}`;
     const progressColumn = padToWidth(
       progress,
@@ -536,7 +567,7 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     const stateColumn = padToWidth(state, 6);
     const prefix = showProgress
       ? `${id}  ${progressColumn}  ${stateColumn}  `
-      : `${id} ${state} `;
+      : `${id} ${padToWidth(state, 6)} `;
     const task = member.item || 'Delegated agent';
     const latest = member.latest.length > 0 && member.latest !== task ? member.latest : undefined;
     const detail = member.phase === 'suspended' || isTerminalPhase(member.phase)
@@ -650,7 +681,10 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     this.recordActivity(member.index, normalizedDetail.length > 0 ? `${label}: ${normalizedDetail}` : label);
   }
 
-  /** Progress only ever advances; stages map to observed events, never to time. */
+  /**
+   * Progress only ever advances; stages map to observed events, never to time.
+   * Creep is per observed event too (each streamed delta), so no timers exist.
+   */
   private advanceMemberProgress(member: DynamicWorkflowMember, targetPercent: number): void {
     member.progressPercent = Math.max(member.progressPercent, targetPercent);
   }
@@ -1026,7 +1060,7 @@ function parsePartialJsonString(
     if (escaped === 'u') {
       const hex = text.slice(index + 2, index + 6);
       if (/^[0-9a-fA-F]{4}$/.test(hex)) {
-        value += String.fromCharCode(Number.parseInt(hex, 16));
+        value += String.fromCodePoint(Number.parseInt(hex, 16));
         index += 5;
         continue;
       }

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

@@ -31,7 +31,14 @@ export const DYNAMIC_WORKFLOW_RENDERING = {
   startedProgress: 20,
   modelActivityProgress: 50,
   toolActivityProgress: 75,
-  finalizingProgress: 90,
+  // Each streamed model delta creeps progress toward a ceiling instead of
+  // pinning it: p += max(minStep, (ceiling - p) * rate), clamped to the
+  // ceiling. The minimum step keeps the tail visibly moving instead of
+  // asymptoting into a stall. Still event-driven, never a timer.
+  progressCreepRate: 0.03,
+  progressCreepMinStep: 0.15,
+  midworkCreepCeiling: 74,
+  finalizingCreepCeiling: 99,
   // Two 2×4 Braille cells form a compact 4×4 dotted cube that fills bottom-up.
   cubeFillLevels: [' ', '⡀', '⣀', '⣄', '⣤', '⣦', '⣶', '⣷', '⣿'],
 } as const;

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

@@ -7,7 +7,7 @@ import {
   type DynamicWorkflowMissionControlOptions,
   dynamicWorkflowResultSummaryFromOutput,
 } from '#/tui/components/messages/dynamic-workflow-mission-control';
-import { BRAILLE_SPINNER_INTERVAL_MS } from '#/tui/constant/rendering';
+import { BRAILLE_SPINNER_INTERVAL_MS, DYNAMIC_WORKFLOW_RENDERING } from '#/tui/constant/rendering';
 import { currentTheme, darkColors } from '#/tui/theme';
 
 const DESCRIPTION = 'Review the interface';
@@ -29,9 +29,15 @@ function memberLine(output: string, index: number): string {
   return line;
 }
 
+function displayedPercent(output: string, index: number): number {
+  const match = /(\d+)%/u.exec(memberLine(output, index));
+  if (match === null) throw new Error(`Missing percent for member ${String(index)}`);
+  return Number(match[1]);
+}
+
 function aggregateLine(output: string): string {
   const line = output.split('\n').find((candidate) =>
-    /\b(?:Orchestrating|Completed|Failed|Cancelled)\b/u.test(strip(candidate))
+    /\b(?:Orchestrating|Finalizing|Completed|Failed|Cancelled)\b/u.test(strip(candidate))
   );
   if (line === undefined) throw new Error('Missing Dynamic Workflow aggregate');
   return line;
@@ -508,7 +514,7 @@ describe('DynamicWorkflowMissionControlComponent', () => {
     component.recordToolCall({ agentId: 'agent-1', name: 'Read' });
     expectProgress(75, '⣶');
     component.appendModelDelta({ agentId: 'agent-1', delta: 'Summarizing' });
-    const activeOutput = expectProgress(90, '⣷');
+    const activeOutput = expectProgress(75, '⣶');
     expect(aggregateLine(activeOutput)).toContain('0/1 complete');
     expect(aggregateLine(activeOutput)).not.toMatch(/\b\d+%/u);
     expect(aggregateLine(activeOutput)).not.toContain('━');
@@ -591,4 +597,116 @@ describe('DynamicWorkflowMissionControlComponent', () => {
       expect(output.includes('PROGRESS')).toBe(showsProgress);
     },
   );
+
+  it('creeps past 90 across streamed deltas and completes only on the terminal event', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['Long streaming work'] });
+    component.markInputComplete();
+    register(component, 'agent-1');
+    component.markStarted('agent-1');
+    component.recordToolCall({ agentId: 'agent-1', name: 'Read' });
+
+    for (let index = 0; index < 10; index += 1) {
+      component.appendModelDelta({ agentId: 'agent-1', delta: `chunk ${String(index)} ` });
+    }
+    const early = displayedPercent(renderText(component, 100), 1);
+    // No snap to 90: the finalizing phase climbs from 75 instead of jumping.
+    expect(early).toBeGreaterThan(75);
+    expect(early).toBeLessThan(90);
+
+    for (let index = 0; index < 200; index += 1) {
+      component.appendModelDelta({ agentId: 'agent-1', delta: 'more ' });
+    }
+    const late = displayedPercent(renderText(component, 100), 1);
+    expect(late).toBeGreaterThan(90);
+    expect(late).toBeLessThan(100);
+
+    component.markCompleted('agent-1', 'Done');
+    expect(displayedPercent(renderText(component, 100), 1)).toBe(100);
+  });
+
+  it('keeps mid-work delta creep under the tool-activity stage until a tool call lifts it', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['Chatty work'] });
+    component.markInputComplete();
+    register(component, 'agent-1');
+    component.markStarted('agent-1');
+
+    for (let index = 0; index < 300; index += 1) {
+      component.appendModelDelta({ agentId: 'agent-1', delta: 'more ' });
+    }
+    const midwork = displayedPercent(renderText(component, 100), 1);
+    expect(midwork).toBeGreaterThan(50);
+    expect(midwork).toBeLessThan(DYNAMIC_WORKFLOW_RENDERING.toolActivityProgress);
+
+    component.recordToolCall({ agentId: 'agent-1', name: 'Read' });
+    expect(displayedPercent(renderText(component, 100), 1))
+      .toBeGreaterThanOrEqual(DYNAMIC_WORKFLOW_RENDERING.toolActivityProgress);
+  });
+
+  it('shimmers Finalizing once every member is terminal but the result has not arrived', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['One', 'Two'] });
+    component.markInputComplete();
+    component.registerSubagent({ agentId: 'agent-1', dynamicWorkflowIndex: 1 });
+    component.registerSubagent({ agentId: 'agent-2', dynamicWorkflowIndex: 2 });
+    component.markStarted('agent-1');
+    component.markStarted('agent-2');
+    component.markCompleted('agent-1', 'Done');
+
+    const running = renderText(component, 100);
+    expect(running).toContain('Orchestrating');
+    expect(running).not.toContain('Finalizing');
+
+    component.markCompleted('agent-2', 'Done');
+    const finalizing = renderText(component, 100);
+    expect(finalizing).toContain('Finalizing');
+    expect(finalizing).not.toContain('Orchestrating');
+
+    component.applyResult([
+      '<dynamic_workflow_result>',
+      '<subagent index="1" outcome="completed">Done</subagent>',
+      '<subagent index="2" outcome="completed">Done</subagent>',
+      '</dynamic_workflow_result>',
+    ].join('\n'));
+    const done = renderText(component, 100);
+    expect(done).toContain('✓ Completed');
+    expect(done).not.toContain('Finalizing');
+  });
+
+  it('keeps Orchestrating while an out-of-band member beyond knownTotal still runs', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['One', 'Two'] });
+    component.markInputComplete();
+    component.registerSubagent({ agentId: 'agent-1', dynamicWorkflowIndex: 1 });
+    component.registerSubagent({ agentId: 'agent-2', dynamicWorkflowIndex: 2 });
+    component.registerSubagent({ agentId: 'agent-3', dynamicWorkflowIndex: 3 });
+    component.markStarted('agent-3');
+    component.markCompleted('agent-1', 'Done');
+    component.markCompleted('agent-2', 'Done');
+
+    const output = renderText(component, 100);
+    expect(output).toContain('● RUN');
+    expect(output).toContain('Orchestrating');
+    expect(output).not.toContain('Finalizing');
+
+    component.markCompleted('agent-3', 'Done');
+    expect(renderText(component, 100)).toContain('Finalizing');
+  });
+
+  it('aligns narrow member rows and the header on the same task column', () => {
+    const component = prepareObservedWorkflow();
+    const output = renderText(component, 50);
+    const unframe = (line: string) => line.replace(/^│ /u, '');
+    const running = unframe(memberLine(output, 1));
+    const completed = unframe(memberLine(output, 2));
+    const headerLine = output.split('\n').find((line) => line.includes('STATE'));
+    if (headerLine === undefined) throw new Error('Missing Dynamic Workflow table header');
+    const header = unframe(headerLine);
+
+    const taskColumn = running.indexOf('Layout hierarchy');
+    expect(taskColumn).toBeGreaterThan(0);
+    expect(completed.indexOf('Interaction audit')).toBe(taskColumn);
+    expect(header.indexOf('TASK')).toBe(taskColumn);
+  });
 });