fix(dynamic-workflow): address PR review findings

Add the Unicode flag to the /workflow model parser so it satisfies the
repo's require-unicode-regexp rule. Assert the cleared state in the
model-preference test instead of only its status message, and extend the
batch propagation test to the resume and retry launch paths. Document the
fallback to the calling agent's model and the unresolved-alias fallback in
the tool description, not only in the reference docs.

Author: elkaix

apps/pythinker-code/src/tui/commands/dynamic-workflow.ts

@@ -111,7 +111,7 @@ function withWorkerModelInstruction(prompt: string, model: string | undefined):
 
 /** Returns true when the input was a `model` subcommand and has been handled. */
 function handleModelSubcommand(host: SlashCommandHost, input: string): boolean {
-  const match = /^model(?:\s+(.*))?$/i.exec(input);
+  const match = /^model(?:\s+(.*))?$/iu.exec(input);
   if (match === null) return false;
 
   const value = match[1]?.trim() ?? '';

apps/pythinker-code/test/tui/commands/dynamic-workflow.test.ts

@@ -347,6 +347,7 @@ describe('handleDynamicWorkflowCommand', () => {
 
     await handleDynamicWorkflowCommand(host, 'model deepseek-v4');
     expect(host.showStatus).toHaveBeenLastCalledWith('Dynamic Workflow subagents will use deepseek-v4.');
+    expect(host.state.appState.dynamicWorkflowModel).toBe('deepseek-v4');
 
     await handleDynamicWorkflowCommand(host, 'model');
     expect(host.showStatus).toHaveBeenLastCalledWith(
@@ -357,6 +358,7 @@ describe('handleDynamicWorkflowCommand', () => {
     expect(host.showStatus).toHaveBeenLastCalledWith(
       'Dynamic Workflow subagents now use this session model.',
     );
+    expect(host.state.appState.dynamicWorkflowModel).toBeUndefined();
 
     // A model subcommand must never be mistaken for a task prompt.
     expect(session.setDynamicWorkflowMode).not.toHaveBeenCalled();

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

@@ -4,7 +4,7 @@ Use DynamicWorkflow when several independent subagents should run in parallel. W
 
 Use `resume_agent_ids` to continue subagents that already exist from earlier work, such as ones that failed: map each agent id to the prompt for that resumed subagent (usually `continue` if no extra information is needed). You may combine `resume_agent_ids` with `items` in the same call to resume existing subagents and launch new ones. Do not duplicate resumed work in `items`.
 
-Use `model` and `effort` to run this workflow's subagents on a different model than the one orchestrating them, such as a cheaper or faster model for mechanical work while the orchestration stays on the current model. Both apply to every subagent in the call. Omit them to use the subagent type's own settings.
+Use `model` and `effort` to run this workflow's subagents on a different model than the one orchestrating them, such as a cheaper or faster model for mechanical work while the orchestration stays on the current model. Both apply to every subagent in the call. Omitting either falls back to the subagent type's own setting, and then to your current setting. A `model` that is not a configured alias also falls back to your current model rather than failing the workflow.
 
 Use enough subagents to keep the work focused and parallel. DynamicWorkflow supports up to 128 subagents, and launches are queued automatically, so it is safe to split large tasks into many clear, independent items. Workflow subagents have no automatic timeout; they run until completion, failure, or user cancellation.
 

packages/agent-core/test/session/subagent-batch.test.ts

@@ -669,20 +669,51 @@ describe('SubagentBatch scheduling contract', () => {
     }
   });
 
-  it('carries a task model and effort through to the launcher', async () => {
-    const { runBatch, attempts } = createMockBatchRunner();
-    const running = runBatch([routedTask(1), routedTask(2)], { signal });
-    await Promise.resolve();
-
-    // A workflow routed to a cheaper model must reach every spawned child;
-    // dropping it here would silently run the batch on the parent's model.
-    expect(attempts).toHaveLength(2);
-    for (const attempt of attempts) {
-      expect(attempt.runOptions.modelAlias).toBe('implementer-model');
-      expect(attempt.runOptions.thinkingLevel).toBe('medium');
-      attempt.outcome.resolve({ task: attempt.task, status: 'completed', result: 'done' });
+  it('carries a task model and effort through spawn, resume, and retry attempts', async () => {
+    vi.useFakeTimers();
+    try {
+      const { runBatch, attempts } = createMockBatchRunner();
+      const resumeTask: QueuedSubagentTask<number> = {
+        ...routedTask(2),
+        kind: 'resume',
+        resumeAgentId: 'agent-2',
+      };
+      const running = runBatch([routedTask(1), resumeTask, routedTask(3)], { signal });
+      void running.catch(() => {});
+
+      await vi.advanceTimersByTimeAsync(0);
+      expect(attempts).toHaveLength(3);
+      attempts.forEach((attempt) => {
+        attempt.markReady();
+      });
+
+      // Rate-limit one attempt so the batch re-launches it through the retry
+      // path, which is the third way a child can be started. Another task has
+      // to finish first to free the shrunken capacity, and a third has to stay
+      // unfinished so the rate-limited one suspends instead of failing.
+      const rateLimitedAgentId = `agent-${String(attempts[0]!.task.data)}`;
+      attempts[0]!.outcome.resolve({ type: 'rate_limited', agentId: rateLimitedAgentId });
+      attempts[1]!.outcome.resolve({ task: attempts[1]!.task, status: 'completed', result: 'done' });
+      await vi.advanceTimersByTimeAsync(3000);
+      expect(attempts).toHaveLength(4);
+      expect(attempts[3]!.retryAgentId).toBe(rateLimitedAgentId);
+
+      // A workflow routed to a cheaper model must reach every child however it
+      // was started; dropping it on any path silently runs that child on the
+      // parent's model.
+      for (const attempt of attempts) {
+        expect(attempt.runOptions.modelAlias).toBe('implementer-model');
+        expect(attempt.runOptions.thinkingLevel).toBe('medium');
+      }
+
+      attempts.slice(2).forEach((attempt) => {
+        attempt.outcome.resolve({ task: attempt.task, status: 'completed', result: 'done' });
+      });
+      await vi.advanceTimersByTimeAsync(0);
+      await running;
+    } finally {
+      vi.useRealTimers();
     }
-    await running;
   });
 });