@@ -76,7 +76,7 @@ Plan mode is a constrained working state: once entered, `Write` and `Edit` are r
 | --- | --- | --- |
 | `TodoList` | Auto-allow | Manage a task to-do list |
 
-**`TodoList`** maintains a visible subtask list across multi-step operations; state is stored within the Agent session. The `todos` parameter accepts an array where each item has a `title` and `status` (`pending` / `in_progress` / `done`). Omitting `todos` queries the current list; passing an empty array clears it.
+**`TodoList`** maintains a visible subtask list across multi-step operations; state is stored within the Agent session. The `todos` parameter accepts an array where each item has a `title` and `status` (`pending` / `in_progress` / `done`). TodoWrite-compatible items can use `content`, `activeForm`, and `completed`; `done` and `completed` are equivalent with either item shape. Omitting `todos` queries the current list; passing an empty array clears it.
 
 ## Collaboration Tools
 
@@ -97,7 +97,7 @@ Each entry in `items` launches one new subagent: without `prompt_template`, ever
 
 Pass `subagent_type` to choose the profile used by every spawned subagent, or omit it to use `coder`. Pass `model` and `effort` to run this workflow's subagents on a different model than the agent orchestrating them — a cheaper or faster model for mechanical work, for example; both apply to every subagent in the call, and omitting them falls back to the subagent profile's own settings and then to the calling agent's. A `model` the provider cannot resolve falls back to the calling agent's model rather than failing the run.
 
-Without `resume_agent_ids`, the tool requires at least 2 items; with `resume_agent_ids`, it can resume one or more existing subagents. The tool supports up to 128 total subagents, waits for all of them to finish, and returns an aggregated report. Workflow subagents have no automatic timeout; they run until completion, failure, or user cancellation.
+Without `resume_agent_ids`, the tool requires at least 2 items; with `resume_agent_ids`, it can resume one or more existing subagents. Calls that fail these plan checks are rejected before an approval request is shown. The tool supports up to 128 total subagents, waits for all of them to finish, and returns an aggregated report. Workflow subagents have no automatic timeout; they run until completion, failure, or user cancellation.
 
 If a model response calls `DynamicWorkflow`, that call must be the only tool call in the response; to run several workflows, call one `DynamicWorkflow`, wait for its result, then call the next, or combine the work into a single workflow.
 
 
@@ -1,6 +1,6 @@
 Launch multiple subagents from complete prompts, one prompt template, existing agent resumes, or a combination.
 
-Use DynamicWorkflow when several independent subagents should run in parallel. Without `prompt_template`, every `items` entry is a complete subagent prompt. When many subagents should run the same kind of task over different inputs, provide a template whose placeholder is exactly `{{item}}`. For example, with `prompt_template` set to `Review {{item}} for likely regressions.` and `items` set to `["src/a.ts", "src/b.ts"]`, DynamicWorkflow launches two new subagents with those two concrete prompts.
+Use DynamicWorkflow when several independent subagents should run in parallel. Without `resume_agent_ids`, provide at least two non-empty items. Without `prompt_template`, every `items` entry is a complete subagent prompt. When many subagents should run the same kind of task over different inputs, provide a template whose placeholder is exactly `{{item}}`. For example, with `prompt_template` set to `Review {{item}} for likely regressions.` and `items` set to `["src/a.ts", "src/b.ts"]`, DynamicWorkflow launches two new subagents with those two concrete prompts.
 
 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`.
 
 
@@ -88,7 +88,7 @@ export const DynamicWorkflowToolInputSchema = z
       .array(z.string())
       .optional()
       .describe(
-        `Each item launches one new subagent. Items fill ${PROMPT_TEMPLATE_PLACEHOLDER} when prompt_template is provided; otherwise they are complete prompts.`,
+        `Each item launches one new subagent. Without resume_agent_ids, provide at least two non-empty items. Items fill ${PROMPT_TEMPLATE_PLACEHOLDER} when prompt_template is provided; otherwise they are complete prompts.`,
       ),
     resume_agent_ids: z
       .record(z.string().trim().min(1), z.string().trim().min(1))
@@ -168,6 +168,13 @@ export class DynamicWorkflowTool implements BuiltinTool<DynamicWorkflowToolInput
   }
 
   resolveExecution(args: DynamicWorkflowToolInput): ToolExecution {
+    try {
+      createDynamicWorkflowSpecs(args, (agentId) =>
+        this.subagentHost.getDynamicWorkflowItem(agentId),
+      );
+    } catch (error) {
+      return { isError: true, output: error instanceof Error ? error.message : String(error) };
+    }
     const workflow = dynamicWorkflowPreview(args);
     const approvalSubject = dynamicWorkflowApprovalSubject(args, workflow);
     return {
@@ -358,9 +365,8 @@ function hasMinimumDynamicWorkflowInputs(itemCount: number, resumeCount: number)
  * What the call is about to launch, for the approval panel — the counted
  * subagents, the work each one gets, and how much prompt that adds up to.
  *
- * Built from the arguments alone and deliberately total: `resolveExecution`
- * runs before `createDynamicWorkflowSpecs` validates anything, so a call this
- * function threw on would never reach the panel that exists to refuse it.
+ * Built from the arguments alone after `createDynamicWorkflowSpecs` validates
+ * the plan, so an invalid workflow never reaches the approval panel.
  * `prompt_tokens` is the summed prompt estimate, which is a real input size —
  * not a guess at what the run will finally cost.
  */
 
@@ -20,7 +20,7 @@ Use this tool to maintain a structured TODO list as you work through a multi-ste
 
 **How to use:**
 - Call with `todos: [...]` to replace the full list. Use `title` plus an optional present-continuous `activeForm`; statuses are pending / in_progress / done.
-- TodoWrite-compatible `content`, required `activeForm`, and completed status are also accepted.
+- TodoWrite-compatible `content`, required `activeForm`, and completed status are also accepted. `done` and `completed` are equivalent with either item shape.
 - Call with no arguments to retrieve the current list without changing it.
 - Call with `todos: []` to clear the list.
 - Keep titles short and actionable (e.g. "Read session-control.ts", "Add planMode flag to TurnManager").
 
@@ -48,18 +48,22 @@ declare module '../../store' {
 
 // ── Schema ───────────────────────────────────────────────────────────
 
+const TodoInputStatusSchema = z
+  .enum(['pending', 'in_progress', 'done', 'completed'])
+  .describe('Current status of the todo. done and completed are equivalent.');
+
 const NativeTodoItemSchema = z.object({
   title: z.string().min(1).describe('Short, actionable title for the todo.'),
   activeForm: z.string().min(1).optional().describe('Present-continuous activity label.'),
-  status: z.enum(['pending', 'in_progress', 'done']).describe('Current status of the todo.'),
+  status: TodoInputStatusSchema,
 });
 
 // Accept the older TodoWrite-style shape for compatibility, then normalize it
 // into the native TodoList store/render contract below.
 const TodoWriteItemSchema = z.object({
   content: z.string().min(1).describe('Imperative description of the task.'),
   activeForm: z.string().min(1).describe('Present-continuous activity label.'),
-  status: z.enum(['pending', 'in_progress', 'completed']).describe('Current status of the todo.'),
+  status: TodoInputStatusSchema,
 });
 
 type TodoListInputItem =
@@ -172,16 +176,17 @@ export class TodoListTool implements BuiltinTool<TodoListInput> {
 }
 
 function normalizeTodoItem(todo: TodoListInputItem): TodoItem {
+  const status = todo.status === 'completed' ? 'done' : todo.status;
   if ('title' in todo) {
     return {
       title: todo.title,
       activeForm: todo.activeForm,
-      status: todo.status,
+      status,
     };
   }
   return {
     title: todo.content,
     activeForm: todo.activeForm,
-    status: todo.status === 'completed' ? 'done' : todo.status,
+    status,
   };
 }
@@ -1068,15 +1068,15 @@ describe('current builtin collaboration tools', () => {
       },
       output: 'prompt_template must include the {{item}} placeholder.',
     },
-  ])('DynamicWorkflow rejects $name at execution time', async ({ input, output }) => {
+  ])('DynamicWorkflow rejects $name before approval', ({ input, output }) => {
     const host = mockSubagentHost({ runQueued: vi.fn() });
     const dynamicWorkflowMode = mockDynamicWorkflowMode();
     const tool = new DynamicWorkflowTool(host, dynamicWorkflowMode);
 
-    const result = await executeTool(tool, context(input));
+    const result = tool.resolveExecution(input);
 
-    expect(result.output).toBe(output);
-    expect(result.isError).toBe(true);
+    expect(result).toEqual({ isError: true, output });
+    expect(dynamicWorkflowMode.enter).not.toHaveBeenCalled();
     expect(host.runQueued).not.toHaveBeenCalled();
   });
 
@@ -1598,6 +1598,7 @@ describe('workflowSizeGuideline', () => {
 
     const unrestrictedTool = new DynamicWorkflowTool(host, mockDynamicWorkflowMode(), 'unrestricted');
     expect(unrestrictedTool.description).toContain('DynamicWorkflow supports up to 128 subagents');
+    expect(unrestrictedTool.description).toContain('at least two non-empty items');
     expect(unrestrictedTool.description).not.toContain('Workflow size guideline:');
   });
 });
 
@@ -15,6 +15,7 @@ import {
   TodoListTool,
   type TodoItem,
 } from '../../src/tools/builtin/state/todo-list';
+import { compileToolArgsValidator, validateToolArgs } from '../../src/tools/args-validator';
 import type { ToolStore } from '../../src/tools/store';
 import { executeTool } from './fixtures/execute-tool';
 
@@ -64,6 +65,18 @@ describe('TodoListTool', () => {
         todos: { type: 'array' },
       },
     });
+    const validator = compileToolArgsValidator(tool.parameters);
+    expect(
+      validateToolArgs(validator, {
+        todos: [
+          {
+            title: 'Map logical groups',
+            activeForm: 'Mapping logical groups',
+            status: 'completed',
+          },
+        ],
+      }),
+    ).toBeNull();
   });
 
   it('description includes an Avoid churn section with the anti-spin guardrails', () => {
@@ -178,6 +191,46 @@ describe('TodoListTool', () => {
     ]);
   });
 
+  it('normalizes done and completed with either item shape', async () => {
+    const { tool, getTodos } = makeTool();
+    const parsed = TodoListInputSchema.parse({
+      todos: [
+        {
+          title: 'Inspect the implementation',
+          activeForm: 'Inspecting the implementation',
+          status: 'completed',
+        },
+        {
+          content: 'Run focused tests',
+          activeForm: 'Running focused tests',
+          status: 'done',
+        },
+        { title: 'Continue review', status: 'pending' },
+      ],
+    });
+
+    await executeTool(tool, {
+      turnId: 't1',
+      toolCallId: 'call_1',
+      args: parsed,
+      signal,
+    });
+
+    expect(getTodos()).toEqual([
+      {
+        title: 'Inspect the implementation',
+        activeForm: 'Inspecting the implementation',
+        status: 'done',
+      },
+      {
+        title: 'Run focused tests',
+        activeForm: 'Running focused tests',
+        status: 'done',
+      },
+      { title: 'Continue review', status: 'pending' },
+    ]);
+  });
+
   it('renders a done todo with a marker matching the status enum value', async () => {
     const { tool } = makeTool([{ title: 'shipped', status: 'done' }]);