Command purpose:
- Use `CMD: create_thread_batch` when the assigned work requires SYS to create multiple threads as one atomic fan-out operation.
- `create_thread_batch` is an envelope around one or more canonical inner `CMD: create_thread` requests.
- Prefer same-thread handoff when the work can be completed with one normal linear handoff.
- Use batch creation when the work naturally decomposes into multiple independent child tasks that can proceed in parallel or in any order.
- Use batch creation when each child thread has a clear deliverable and validation target, all children share the same parent-resume aggregation step, and the fan-out benefit outweighs child-thread overhead.
- Use batch creation when the parent should pause until all direct children are Closed, then resume to aggregate results.
- Do not use batch creation merely because multiple narrow tasks can be named; use it only when the child-thread overhead is justified across the full fan-out.
- Do not use `CMD: create_thread_batch` for unrelated work items that should not share one parent blocked-on-children dependency.
- Do not use `CMD: create_thread_batch` merely for cosmetic organization.

Required parameter order:

CMD: create_thread_batch
thread_batch:
BEGIN
CMD: create_thread
<complete canonical create_thread parameter block from ## SYS CMD CREATE THREAD INSTRUCTIONS>

CMD: create_thread
<complete canonical create_thread parameter block from ## SYS CMD CREATE THREAD INSTRUCTIONS>
END

Batch selection:
- Use `CMD: create_thread_batch` when multiple child threads should be created from the same parent message as one fan-out.
- Use batch fan-out when child tasks can proceed independently and can run in parallel or in any order.
- Use batch fan-out when all children share the same parent-resume aggregation step and the aggregation benefit outweighs the overhead of child creation, closure, and parent resume.
- Use batch fan-out when the parent should remain blocked-on-children until all direct children are Closed.
- Prefer same-thread handoff instead of batch fan-out when the work can be completed with one normal linear handoff.
- Do not use batch creation for a set of narrow one-step implementation, smoke, or review actions unless parallelism, artifact isolation, authority boundaries, remote-actor artifact access, or parent/child lifecycle separation clearly justify child threads.
- Use separate `CMD: create_thread` messages instead of batch when thread creation depends on the result of a prior child or decision.
- Do not use batch creation when the tasks are sequentially dependent.
- Do not use batch creation when each task needs a different parent lifecycle or should not block the same parent.

Inner create-thread requirements:
- Each inner `CMD: create_thread` block must be a complete canonical create-thread request.
- Each inner `CMD: create_thread` block must follow the `## SYS CMD CREATE THREAD INSTRUCTIONS` prompt section.
- `## SYS CMD CREATE THREAD INSTRUCTIONS` is the source of truth for inner create-thread parameter order, parameter selection, bucket selection, owner selection, `thread_m0_body`, and `parent_thread_pending_art`.
- Do not duplicate or reinterpret create-thread rules in this batch instruction section.
- The actor requesting the batch is the owner for each created child thread, unless the `## SYS CMD CREATE THREAD INSTRUCTIONS` prompt section says otherwise.
- For MRC batch children that should run immediately, use `thread_bucket: A` or `thread_bucket: H`, not `thread_bucket: P`.
- Use `thread_bucket: P` only when deliberately creating non-runnable parked child threads. Parked children remain Open and still block the parent.

parent_thread_pending_art across a batch:
- Each inner `parent_thread_pending_art` block applies to that specific inner `CMD: create_thread` request.
- All pending-art slots declared across the batch must target the same expected parent message-after-outgoing.
- The expected parent message-after-outgoing is the immediate next message in the same parent thread after your outgoing `CMD: create_thread_batch` message.
- If your assigned message is `T#MN` and your outgoing message is `T#M(N+1)`, then the expected message-after-outgoing is `T#M(N+2)`.
- Pending-art filenames must be unique within the batch for the same expected message-after-outgoing.
- SYS aggregates all valid pending-art slots from the inner create-thread requests into the parent message-after-outgoing.

Create-thread-batch message semantics:
- `CMD: create_thread_batch` is atomic.
- SYS validates every inner `CMD: create_thread` request before creating any thread.
- If any inner request is invalid, SYS creates no threads.
- If all inner requests are valid, SYS creates all requested threads.
- SYS publishes one parent message-after-outgoing in the original parent thread.
- The parent message-after-outgoing includes a `Created Threads` section listing all created direct child thread IDs and topics.
- The parent message-after-outgoing includes a `Pending Art Slots` section containing the aggregate of all pending-art slots declared across the batch.
- SYS routes the message-after-outgoing back to the original requesting `FROM` actor.
- When the parent thread later resumes after blocked-on-children, the assigned actor may use the `Created Threads` section as the authoritative child-discovery record.
- If no parent pending-art slots were declared, the assigned actor may inspect the listed child thread files to reconstruct child results and summarize them in the parent thread.
- If parent pending-art slots were declared, the resumed parent actor should consume the materialized pending-art files from the parent message-after-outgoing.
- A child-thread completion or termination instruction applies only to that child thread.
- The parent thread must still complete its own contract after all direct children are Closed.
- Do not infer that the parent thread should terminate merely because its child threads are Closed.
- If the parent deliverable requires synthesis, aggregation, inspection, or presentation to a recipient, the parent-resume actor must complete that deliverable before any completion verification or termination.

Required output rules:
- Route the outgoing message to SYS only.
- After the `TO: SYS` routing line and blank line, start the message body with `CMD: create_thread_batch`.
- Do not include extra prose, notes, headings, or sections beyond the required parameter.
- Use the exact CMD and parameter names.
- Use the exact parameter order shown above.
- `thread_batch` is required.
- Use `BEGIN` and `END` for `thread_batch`.
- `BEGIN` and `END` must appear alone on their own lines.
- `thread_batch` must contain one or more complete canonical `CMD: create_thread` blocks.
- `CMD:` lines inside `thread_batch` are intentional inner batch entries, not additional top-level SYS commands.
- Do not include more than one top-level SYS CMD outside the `thread_batch` block.
- Do not mix `CMD: create_thread_batch` with other SYS CMD families in one outgoing message.
- Do not include `CMD: terminate_thread` in the same outgoing message as `CMD: create_thread_batch`.
