fix(dynamic-workflow): stop blank items from breaking the run they were meant to save

Three defects, all fallout from dropping blank items rather than rejecting the
call, and all in the scenario that change exists to handle.

The note explaining the drop was prepended to the tool output, but consumers
match the result document anchored at the start of that output. A run that
dropped an item therefore parsed as unsupported and rendered as failed despite
every subagent succeeding. The note now follows the results, and both sides pin
the ordering: the producer asserts the envelope comes first, the renderer
asserts it still parses with the note attached.

The transcript counted blank entries when sizing the panel, so a dropped item
left a row queued forever and held the header below its total.

The schema still capped the raw item count, so 128 real prompts plus one blank
was rejected whole -- reopening the hole at the boundary. The cap now applies to
the items that survive, and going over it fails inside the tool with a readable
message instead of discarding every prompt.

Author: elkaix

.changeset/workflow-blank-items-followups.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Finish handling blank Dynamic Workflow items. A run that dropped one reported its results after a note explaining the drop, which made the whole result parse as unsupported and rendered a successful run as failed; the note now follows the results. A blank entry also no longer leaves a row queued forever with the header stuck below its total, and no longer pushes a full item list over the subagent cap and back into whole-call rejection.

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

@@ -709,7 +709,14 @@ export class DynamicWorkflowMissionControlComponent implements Component {
 /** Item list from the completed tool-call `items` argument. */
 export function dynamicWorkflowItemsFromArgs(args: Record<string, unknown>): string[] {
   const items = args['items'];
-  return Array.isArray(items) ? items.map(itemLabel) : [];
+  if (!Array.isArray(items)) return [];
+  // Blank entries are dropped by the engine before any agent is launched, so
+  // counting them here would leave a phantom row waiting forever and pin the
+  // header below its total. Non-strings are kept: the engine rejects those, and
+  // itemLabel renders them readably.
+  return items
+    .filter((item) => typeof item !== 'string' || item.trim().length > 0)
+    .map(itemLabel);
 }
 
 /**

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

@@ -121,6 +121,56 @@ describe('DynamicWorkflowMissionControlComponent', () => {
     }
   });
 
+  it('ignores blank items so no phantom row waits forever', () => {
+    const component = createComponent();
+    // The engine drops the blank before launching anything, so counting it here
+    // would leave a third row queued for good and pin the header at 2/3.
+    component.updateArgs({ items: ['Layout hierarchy', 'Interaction audit', '   '] });
+    component.markInputComplete();
+    register(component, 'agent-1');
+    component.markStarted('agent-1');
+    component.markCompleted('agent-1', 'Done one');
+    register(component, 'agent-2');
+    component.markStarted('agent-2');
+    component.markCompleted('agent-2', 'Done two');
+
+    const output = renderText(component, 120);
+    expect(memberLine(output, 1)).toContain('✓ DONE');
+    expect(memberLine(output, 2)).toContain('✓ DONE');
+    // memberRowCount also counts activity lines, so assert the row's absence.
+    expect(() => memberLine(output, 3)).toThrow(/Missing Dynamic Workflow member 003/u);
+    expect(aggregateLine(output)).toContain('2/2 complete');
+  });
+
+  it('still parses a result that carries the dropped-items note', () => {
+    // agent-core appends this note when it ignores blank items. It used to be
+    // prepended, which made the envelope regex miss and rendered a successful
+    // run as "Unsupported Dynamic Workflow result".
+    const result = [
+      '<dynamic_workflow_result>',
+      '<summary>completed: 1</summary>',
+      '<subagent outcome="completed">Layout hierarchy</subagent>',
+      '</dynamic_workflow_result>',
+      'Note: 1 empty item was ignored; the workflow ran without them.',
+    ].join('\n');
+
+    expect(dynamicWorkflowResultSummaryFromOutput(result)).toEqual({
+      completed: 1,
+      failed: 0,
+      aborted: 0,
+      parsed: true,
+    });
+
+    const component = createComponent();
+    component.updateArgs({ items: ['Layout hierarchy'] });
+    component.markInputComplete();
+    expect(component.applyResult(result)).toBe(true);
+
+    const output = renderText(component, 120);
+    expect(memberLine(output, 1)).toContain('✓ DONE');
+    expect(output).not.toContain('Unsupported');
+  });
+
   it('decodes escaped XML fields and preserves literal closing-tag text', () => {
     const result = [
       '<dynamic_workflow_result>',

packages/agent-core/src/tools/builtin/collaboration/dynamic-workflow.ts

@@ -72,12 +72,12 @@ export const DynamicWorkflowToolInputSchema = z
         `Optional prompt template for each subagent. The ${PROMPT_TEMPLATE_PLACEHOLDER} placeholder is replaced with each item value. When omitted, each item is used as a complete prompt.`,
       ),
     items: z
-      // Deliberately NOT `.min(1)` per item: a model that emits a trailing
-      // empty string would otherwise fail argument validation, which rejects
-      // the WHOLE call before the tool runs and costs a full re-send of every
-      // prompt. Empty entries are dropped and reported by the tool instead.
+      // Deliberately unconstrained per item and unbounded in length: argument
+      // validation rejects the WHOLE call before the tool runs, so a trailing
+      // empty string — or one blank entry pushing a full list one over the cap
+      // — would cost a re-send of every prompt. The tool drops blanks, reports
+      // how many, and enforces the real cap against the surviving count.
       .array(z.string())
-      .max(MAX_DYNAMIC_WORKFLOW_SUBAGENTS)
       .optional()
       .describe(
         `Each item launches one new subagent. Items fill ${PROMPT_TEMPLATE_PLACEHOLDER} when prompt_template is provided; otherwise they are complete prompts.`,
@@ -262,7 +262,10 @@ export class DynamicWorkflowTool implements BuiltinTool<DynamicWorkflowToolInput
     );
     const { dropped } = normalizeWorkflowItems(args.items);
     if (dropped === 0) return rendered;
-    return `${droppedItemsNote(dropped)}\n${rendered}`;
+    // After the envelope, never before it: consumers match the result document
+    // anchored at the start of the output, so a prefix makes a successful run
+    // parse as an unsupported result.
+    return `${rendered}\n${droppedItemsNote(dropped)}`;
   }
 }
 

packages/agent-core/test/tools/builtin-current.test.ts

@@ -386,6 +386,11 @@ describe('current builtin collaboration tools', () => {
     expect(queued.map((task) => task.prompt)).toEqual(['Review src/a.ts', 'Review src/b.ts']);
     // A quietly shorter workflow must not read as one the model sized right.
     expect(result.output).toContain('1 empty item was ignored');
+    // The note must not precede the envelope: consumers match the result
+    // document anchored at the start, so a prefix renders a successful run as
+    // an unsupported result.
+    const outputText = typeof result.output === 'string' ? result.output : '';
+    expect(outputText.trimStart().startsWith('<dynamic_workflow_result')).toBe(true);
   });
 
   it('DynamicWorkflow says items were dropped when too few survive', async () => {
@@ -456,12 +461,15 @@ describe('current builtin collaboration tools', () => {
         items: Array.from({ length: 128 }, (_, index) => `src/${String(index + 1)}.ts`),
       }).success,
     ).toBe(true);
+    // Over the cap now passes argument validation and fails inside the tool
+    // with a readable message. Rejecting at the schema would discard the whole
+    // call -- including the 128 valid prompts -- over one surplus entry.
     expect(
       DynamicWorkflowToolInputSchema.safeParse({
         ...input,
         items: Array.from({ length: 129 }, (_, index) => `src/${String(index + 1)}.ts`),
       }).success,
-    ).toBe(false);
+    ).toBe(true);
     expect(tool.parameters).toMatchObject({
       type: 'object',
       properties: {
@@ -856,6 +864,24 @@ describe('current builtin collaboration tools', () => {
     expect(execution.matchesRule).toBeUndefined();
   });
 
+  it('DynamicWorkflow accepts a full item list carrying a blank entry', async () => {
+    // 128 real prompts plus one blank used to trip the schema's raw-length cap,
+    // which rejected the entire call -- the very hole the blank-item handling
+    // exists to close, reopened at the boundary.
+    const items = [...Array.from({ length: 128 }, (_, index) => `src/${String(index + 1)}.ts`), ''];
+    const input = { description: 'Review files', prompt_template: 'Review {{item}}', items };
+
+    expect(DynamicWorkflowToolInputSchema.safeParse(input).success).toBe(true);
+
+    const host = mockSubagentHost({ runQueued: vi.fn().mockResolvedValue([]) });
+    const tool = new DynamicWorkflowTool(host, mockDynamicWorkflowMode());
+    const result = await executeTool(tool, context(input, 'call_dynamic_workflow'));
+
+    expect(result.isError).not.toBe(true);
+    expect(host.runQueued).toHaveBeenCalledTimes(1);
+    expect((host.runQueued.mock.calls[0]?.[0] as unknown[]).length).toBe(128);
+  });
+
   it('DynamicWorkflow rejects more than 128 subagents at execution time', async () => {
     const host = mockSubagentHost({ runQueued: vi.fn() });
     const dynamicWorkflowMode = mockDynamicWorkflowMode();