Prompt section reads, a Plugin package registry, capped parallel tool calls, and tasks.fanout

[vinniefalco]

This branch lands nine plans, in 34 commits, on how prompts read their own sections, how Hosts install Plugins, and how a model's tool calls run.

• Prompt reads. Section code gets a prompt table with two reads. prompt.section(heading) returns a visible section's own raw Markdown, and prompt.list(heading) returns a list section's items. Both return nil when no visible section has that heading, so an optional read needs no pcall and headings can serve as an index. They replace list_from_section, which could read only list sections and raised on every miss. One lookup, find_visible, now answers every heading lookup, and call and jump keep their not-found error on top of it.
• Prompt reads debt removal. A debt review of the reads led to a cleanup with no behavior change. The parser's section builder splits into named checks, H1's visible set gets one helper, resolve_sibling becomes resolve_visible, two stale docs about reserved tool aliases are corrected, and closed plan records in vibe/ stop listing their todos as pending.
• Package registry. Hosts used to install a Plugin by passing its compile-time Package constant, so nothing could list the available Plugins or install one by name. Now a Host adds packages to a PackageRegistry, lists it, and installs by package name. Every registry holds the Engine-native promptforge/subagents package, which reserves the subagents name so no other Plugin can take it, and offers nothing yet.
• Native docs and in-place reads. A second debt review corrects the native package's text, which claimed it let the model start, wait for, and cancel subagents, and fixes the UnknownPackage advice, which named a step a Host can no longer take. It also stops the Engine from copying sections: every section entry and every jump, call, or fanout target lookup used to clone the sections it could address, subtrees and all. The parser now keeps each prompt body as one shared string that sections point into by byte range, and every lookup reads that shared tree in place.
• Parallel tool calls and tasks.fanout. When a model asked for several tools in one models.loop round, the loop used to run them one at a time. Now the Engine issues the round's catalog calls together, so they run at the same time, and the loop still appends their results once, in the order the model asked for them. Local Lua tools and the task built-ins still run alone. The same plan moves the fanout global onto the tasks table as tasks.fanout(worker, collection), with no compatibility stub, so prompts that call fanout must be updated.
• Workshop waits. Parallel calls made two Workshop agent panel bugs reachable. A sibling call's result switched the composer to Stop while the model's question to the operator was still open, and a second question in the same round stranded the first. The agent session service now keeps every open question in order, offers the oldest, and keeps the composer on Send while any question is open.
• Easy fixes. A follow-up cleanup with no behavior change for prompts, Plugins, or Hosts. The scheduler decides a tool call's route in one place instead of two, a private CallSite enum replaces three loose options, the ToolContext docs state the rule for sibling calls, and the tool_call parse tests move into a file of their own.
• Tool-call cap. Parallel calls had no ceiling: one round could ask for 50 fetches, or eight fanout arms could each ask for ten. Now a run has at most ten tool calls running at once, and the rest wait. When a slot frees, the call issued earliest starts, so the oldest batch finishes first and nothing starves. Model rounds and timers never wait. Each Engine step also lists the tool calls it withdrew when a task ended early, and the Harness drops them, running or waiting, instead of letting them run until they land.
• Tool-call cap debt removal. A debt review of the cap found one debt: the public Plugin contract still said only a cancel could drop a call whose tool survives stops, but a withdrawal now drops one while the run goes on. Plugin::call now holds the one complete list of drop occasions, and the other public copies point to it. Two doc edits ride along: a rule that a call must not wait for another call of the same run, and "in flight or waiting" in RunControl::stop_round. A new test pins that cancelling a task drops its question to the operator.

Plans:

• vibe/2026-10-10-2-prompt-namespace-reads.md
• vibe/2026-10-10-3-prompt-reads-debt-removal.md
• vibe/2026-10-11-1-package-registry.md
• vibe/2026-10-11-2-native-docs-debt-removal.md
• vibe/2026-10-11-3-parallel-tool-calls.md
• vibe/2026-10-11-4-workshop-waits.md
• vibe/2026-10-11-5-easy-fixes.md
• vibe/2026-10-11-6-tool-call-cap.md
• vibe/2026-10-11-7-tool-call-cap-debt.md

Changes

Prompt reads:

• Keep each section's raw Markdown in the parser
• Split find_visible out of resolve_sibling
• Replace list_from_section with prompt.section/list

Prompt reads debt removal:

• Split build_sections into named check helpers
• Give H1's visible set one helper, rename resolve_sibling
• Mark every finished record's open tasks completed
• Rename fanout-arm test and fix reserved-alias docs
• Tidy up vibe/ plans (no plan; it only moves 14 October plan records into vibe/2026-10/)

Package registry:

• Add a one-line description to each Plugin package
• Install Plugins by name from a package registry

Native docs and in-place reads:

• Correct the native subagents and Plugin package docs
• Make the UnknownPackage advice followable
• Resolve jump, call, and fanout targets in place
• Read prompt sections in place at section entry
• Borrow parser intermediates from the prompt body
• Store each prompt's body once and read its text in place

Parallel tool calls and tasks.fanout:

• Run one round's catalog tool calls in parallel
• Move fanout into the tasks table as tasks.fanout

Workshop waits:

• Keep Workshop waits answerable when calls run in parallel

Easy fixes:

• Decide a tool call's route once and type its call site
• Document sibling calls and split the tool_call parse tests

Tool-call cap:

• Report the tool calls each step withdraws
• Run at most the cap of tool calls, oldest first

Tool-call cap debt removal:

• Document every occasion that drops a Plugin call
• Pin that cancelling a task drops its operator question

The nine Close plan commits retire each plan's active marker, and all but the first also mark that plan record's todos completed.

Behavior changes

For prompt authors:

• Breaking: the fanout global is gone, with no stub and no alias, and tasks.fanout(worker, collection) replaces it. A prompt that still calls fanout(...) now fails at run time with a call to a nil global, so every call site must change to tasks.fanout(...). It takes and returns exactly what fanout did: how arms run, how their results are ordered, and when the depth cap fires do not change. It needs no declaration, because tasks is part of the language. fanout also leaves the reserved Engine globals, which drop from 61 to 60.
• The four errors an author can see from that call now name it by its new path: tasks.fanout's second parameter is a collection; ..., tasks.fanout over an empty collection: no work is likely a bug, tasks.fanout results are read-only, and tasks.fanout recursion exceeded cap of 8, parallel to the call wording. The collection key and member errors still use "fanout" as the name of the operation.
• Breaking: list_from_section is gone, with no stub, and prompt.list(heading) replaces it. prompt takes its place as a reserved Engine global, so a Plugin prelude can no longer define prompt. The only in-tree callers were four fanout test fixtures, which now call prompt.list.
• prompt.section(heading) returns the section's own Markdown, from the line after its heading to the next heading of any level, so child sections are left out. Leading blank lines are dropped as whole lines, so an indented first line keeps its indentation, and trailing whitespace is trimmed. Lua fences, thematic breaks, and {{ }} placeholders come back as text, neither run nor rendered. An empty section returns "", and any kind of section can be read, list sections included.
• Both reads search only the caller's visible set, the same set call and jump use: its siblings minus itself plus its direct children, or the whole top-level slice from H1. A heading outside that set (a niece, a grandchild, or the caller itself) and a heading no section has both read as nil, where list_from_section raised not-found.
• Both raise, catchably, only when the call itself is wrong: a non-string target, a malformed heading, or an ambiguous one. prompt.list also raises for a visible section with no list items, and that message now names the trimmed heading as written, as in section `## Rules` has no pre-parsed items, instead of the bare section name.
• Both work in H1 and in a lua shared library. A read at library load time resolves over each replaying VM's own visible set, and a shared function resolves over the visible set of whichever section calls it.
• Since a miss reads nil, tasks.fanout(worker, prompt.list('## Missing')) fails with the collection error, which reads tasks.fanout's second parameter is a collection; for a list section use prompt.list(heading), which returns nil when no visible section has that heading.
• call and jump are unchanged, error messages included. A call to a missing heading still raises and lists only the visible sections.
• Tool calls in one round now run concurrently. In models.loop, a round's unanswered calls go to the Engine as one batch, even a lone call, and the Engine issues the leading catalog calls in one step. The loop resumes once every issued call has landed and appends one assistant record and then the tool records in call order, so the message list never shows a half-answered round. TOOL_CALL_* and ToolResult events fire in landing order, and every ToolResult keeps the round's turn. What models.loop takes and returns does not change, and a round with one catalog call gives the same results as before.
• A local Lua tool or a task built-in (task, task_cancel, task_status, await_tasks) still runs alone. The batch stops in front of it, it runs by itself, and the calls after it go out as the next batch, so [web_a, web_b, grab, web_c] with grab local runs web_a and web_b together, then grab, then web_c. Script tools.call stays a single call.
• Failure keeps its serial meaning. A failed catalog call still becomes untrusted failure text in its slot, and a dropped call fills its slot with the cancelled error. A call the round cannot bind stops the batch: the calls before it still run, the loop raises unbound_tool once they land, nothing is appended, and the calls after it are never issued.
• Same-path writes between sibling calls now conflict. The calls of one round are concurrent store identities, like fanout arms, so one call's write to a path conflicts with a sibling's read or write of it. Two calls in one round that write the same store path now fail the run with a determinism conflict, where before they ran one after another. No shipped Plugin writes the run's store.
• At most ten tool calls run at once in a run. Calls beyond that wait, across every chain and task of the run, and start in the order they were issued. So the oldest batch finishes first, and a later batch never jumps ahead of an earlier batch's leftovers. Model rounds and timers never wait and never count. Results, their order, and what models.loop returns do not change.
• Cancelling a task abandons every call it has out, and so does its owner ending or an ancestor's abort. The Harness now drops those calls at once, running or waiting, instead of letting them run until they land, and the Engine still discards their answers. stop_round drops every call of an in-flight batch and every waiting call, unstarted. A loop under pcall catches the drop as cancelled.

For Plugin authors:

• A Plugin tool can now have several calls from the same model round in flight at once, including several calls to the same tool, up to the run's cap of ten tool calls across every tool. Each call still forks its own store access and ends it when answered. The ToolContext docs now say that calls from one round fork from the calling chain together, so one call's write to a path conflicts with a sibling's read or write of it.

• Plugin::call's invariants now list every occasion the Harness drops a call's future:

  • a stop;
  • the run's end, a cancel included;
  • the early end of the task that made the call: its cancel, its owner's end, or an ancestor's abort.

  Only a stop spares a call whose tool sets survives_stop. That last occasion is new for such tools. The old text said only a cancel could drop them, but a withdrawn ask is now dropped while the run goes on. The promptforge-plugin crate doc and the plugin-user-input docs now point to that list, and ToolDescriptor::survives_stop says the same in its own words.

• A new invariant on Plugin::call: a call must not wait for another call of the same run to finish. The Harness holds calls beyond its cap, so such a wait can stall the run until a stop or a cancel. No in-tree tool does this.

For hosts:

• HostContext::new takes a PackageRegistry by value beside the Host-wide services, and HostContext::install takes a package name as &str instead of a Package. A Host adds each linked Plugin's PACKAGE with PackageRegistry::add, builds the context, and then installs by name, as in host.install(plugin_web::PACKAGE.name, None, Value::Null).
• harness::plugin gains PackageRegistry (new, Default, add, and list, which yields (&Package, PluginKind) pairs in package name order) and PluginKind, a #[non_exhaustive] enum with Native and Linked.
• Every registry holds promptforge/subagents from the start, with the default local name subagents. Installing it meets a prompt that declares subagents but adds no catalog tool and no prelude. A Host that does not install it reports subagents in missing_required for such a prompt.
• InstallError gains three variants. add returns DuplicatePackage, Plugin package `{package}` is already in the registry, for a name the registry holds, the native's included. install returns UnknownPackage, Plugin package `{package}` is not in the registry; add it with PackageRegistry::add before building the HostContext, for a name it does not hold, promptforge/tasks included, since tasks stays a language feature. It returns ReservedName, Plugin package `{package}` cannot be installed as {name}: a native Plugin keeps its own name, and no other package may take it, for the native under any name but subagents and for any other package under subagents, chosen or default. InvalidPackage now comes only from add, and installing the native twice is NameTaken.
• Package gains a public description field and a const fn description builder, empty by default. Package is #[non_exhaustive], so Plugin crates that do not set it still compile. Web, user-input, and MCP describe themselves as "Search the web and fetch pages", "Ask the person running the prompt", and "Tools from one MCP server". Debug for Package now shows the description, and Debug for HostContext shows the registry.
• Workshop adds web, user-input, and MCP to a registry and installs the native after user-input. A refused add or install logs a warning and the rest still run, so an mcp.json server named subagents is now skipped with a warning.
• Parallel calls needed no Harness change, because its effect loop already performed in-flight effects concurrently. The tool-call cap is the Harness's own. Harness::new's doc names the default of ten, and a Host has no setting for it yet.
• RunControl::stop_round's doc now says a stop also drops tool calls waiting for a slot, unstarted, except those that survive stops, which start once a slot frees. It also says a stop reaches the effects in flight or waiting when the loop sees it. RunControl::cancel's doc says every waiting call is answered Dropped too, unstarted.
• Workshop's agent panel keeps every open operator question in the order the server announced it and always offers the oldest, so answering or cancelling one moves on to the next instead of stranding the rest. A sibling call's result no longer switches the panel into its working state while a question is open, so the composer keeps offering Send rather than Stop. After a reconnect the list rebuilds from the server's resend, oldest first. The Workshop server and its wire format do not change.
• The promptforge facade's API listing changes in two lines, both from the tool-call cap. EffectId now derives PartialOrd and Ord, and its doc promises that an effect issued later in a run has a greater id. Step::Pending gains withdrawn: Vec<EffectId>, the tool calls that step orphaned, in effect-id order. The list is empty once the run is decided, and each listed call still owes one answer. Code that drives a Run and matches Step::Pending exhaustively must add the field or ... Nothing in the per-run Plugin snapshot changes.

For contributors:

• The AGENTS.md Plugin definition now says a Host adds packages to its registry and installs by package name, and names three kinds: linked, library (not built yet), and Engine-native (promptforge/subagents, reserved for subagent tools the Engine will implement, not built yet).
• In the Engine crates, find_visible is the one heading lookup and resolve_visible its not-found adapter, both over a borrowed Visible view of the visible set. SlicePath moves to walk_target.rs. The parser keeps the body in one Arc<str>, and a section's Markdown, items, and prose blocks are BodyText ranges into it, so Section::items() returns &[BodyText] while markdown() still returns &str. Test support's synthetic_section drops its items parameter.
• The in-place work changes no observable behavior. Read results, nil on a miss, jump, call, and fanout targets, error texts, the order in which a not-found error lists the visible sections, parse errors, and Debug output for sections and blocks all stay the same, because BodyText compares and prints as its text.
• 133 closed plan records under vibe/ had their frontmatter todo statuses set to completed, replacing 970 pending and 5 in_progress lines and changing nothing outside the frontmatter.
• In the Lua crate's coroutine protocol, Request::ToolCalls holds a round's unanswered calls and its turn, and Answer::ToolCallsResult answers with one text per issued call in call order, or the first failure in call order. Fewer texts than calls marks where the scheduler stopped, and the loop sends that call alone through the old tool_call request, which now serves only that call and script tools.call. A lone local call or task built-in therefore costs one extra exchange between the loop and the Engine, with no I/O. None of this is in the facade.
• In the Engine scheduler, tool_route decides each call's ToolRoute (Builtin, Local, or Catalog) for lone and batched calls alike. dispatch_tool_calls issues catalog calls through prepare_catalog_call in model order and stops at the first other route, and fill_batch_slot fills each slot as its answer lands and resumes the chain once. A private CallSite (Script, Model, Batch) replaces the call_id, turn, and slot options, so a batch slot can only exist beside a model call id. runs_alone and its internal error are gone. When several route lookups fail at once, a frame or local-tool lookup error now surfaces first.
• Chains gain a batch field that abort and teardown clear, and an aborted chain now orphans every pending effect, sorted by effect id, instead of only the first.
• In the Engine scheduler, abort_effect lists every tool call it orphans in a withdrawn buffer that each step drains and sorts into Step::Pending. end clears the buffer after teardown, so a decided run lists none rather than a partial set.
• In the Harness, Flights keeps waiting tool calls as unpolled performer futures in a BTreeMap keyed by effect id, and starts the lowest id while fewer than the cap are in flight. A withdrawal is a third Reach beside a cancel and a stop, so all three share abort's merge in effect order, refill, and teardown. ToolPerformer::max_in_flight is a default method returning ten, and ToolPerformer stays internal to harness-runner. The Driver drops a step's withdrawn calls only after it has queued that step's effects, because one step can issue a call and withdraw it.
• No replay flag gates the batch path. Flags still defines nothing beyond Flags::EMPTY, because no code reads a bit and no run-log replayer feeds recorded answers back. A batch keeps the old issue order, but its effect ids match the old ones only in a run with one live chain. The parallel-tool-calls plan record was corrected in place to say so. The order in which the Harness starts capped calls changes only the order answers land, which the Engine already records as input.
• The eleven tool_call request tests move unchanged from protocol/tests/parse.rs, which sat one line under the 500-line ceiling, into a new parse_tool_call module, and the protocol module overview now lists tool_calls among the rounds models.loop yields.
• The language spec's tasks.fanout entry lives in the separate promptforge-design repository and was updated there, outside this PR.

Known limits

• The promptforge-docs user guide still teaches the removed list_from_section global, in nine chapters under src/language/, and does not mention prompt.section or prompt.list. It also still calls the bare fanout global, 32 times across chapters 01, 02, 07, 08, 09, 14, and 17 (counted at promptforge-docs 44ff253), and never tasks.fanout. The site workflow publishes that checkout beside this repository, so once this lands every published fanout example fails at run time. That repository needs its own change. It was not checked for copies of the Plugin drop contract.
• The task built-ins are not yet gated on installing the native promptforge/subagents package. Leaving the native out only refuses prompts that declare subagents, and a section that calls tools.allow_tasks() still offers the model the task built-ins without the Host's say. That waits for the tasks and subagents overhaul, which will also rewrite the native's description, the AGENTS.md clause, and the PluginKind::Native doc.
• The native offers nothing yet, so a prompt that declares subagents prepares on a Host that installed it but gets no tools from it.
• No Host reads a package's description yet: Workshop builds its registry inside with_plugins and keeps no handle to it. The package selection screen, library Plugins, and per-package config schemas are deferred, and PluginKind has no library kind, though AGENTS.md names one.
• The native's package name is not exported as a constant, so Workshop installs it by the literal "promptforge/subagents", which its test pins.
• Because a miss reads nil, a misspelled heading surfaces later, for example as a nil concatenation or the tasks.fanout collection error. assert(prompt.section(h), msg) is the strict form. A read still cannot name a grandchild.
• Each read still copies the found section's Markdown and items into Lua strings, and each compiled Lua fence keeps its own copy of its source.
• SectionContext::new grows to 80 lines with the slice lookup, which makes it a candidate for a later split.
• The speedup from parallel calls needs a model that asks for several calls in one round. Hosted models commonly do. Local models served by llama.cpp likely ask for one call per round, since llama.cpp's own parallel-tool-call option is off by default, and passing that option through is cppalliance/promptforge#141.
• Local Lua tools, the task built-ins, and script tools.call still run one at a time.
• The cap is fixed at ten per run. A Host or a prompt can't set it, and it can't change mid-run.
• A big batch holds later batches behind it: with the cap at ten, a 40-call batch makes a later one-call batch wait four rounds.
• Calls that survive stops count toward the cap, so an operator question can wait behind slow calls, and the operator sees it only once it starts. A stop can then start a waiting question whose answer is discarded with the stopped round.
• Nothing reports a call as started, so a waiting call shows as running until its result arrives.
• Only tool calls are withdrawn. A cancelled task's model round runs to the end, and its tokens are spent.
• A deliberate Stop while an operator question is open still drops the round's running sibling calls and discards the round, the operator's answer included.
• Workshop wait frames name no call id, so the panel fix assumes one client per conversation. A second client attached to the same conversation could keep generating off after its question is answered elsewhere, until the next reply. Shipped Workshop gives each agent panel its own socket and session.
• crates/harness-internal/runner/src/effect_loop.rs sits at 499 of its 500 allowed lines, so its next change has to move something out first.

Testing

• For the first four plans, the full workspace gates pass on the native-docs plan's last step commit from before its rebase onto master. That commit's code is identical to e62bd6d77, the last of those four plans' commits; the two differ only in the plan record and vibe/ACTIVE. The gates cover the formatting check, clippy with warnings denied on both partitions, the headless gateway check, cargo deny, cargo audit, cargo hakari verify, five doc builds with warnings denied, the facade API check, the site build, the Workshop and gateway config UI typechecks and npm suites, the docs-claims scan, and the build-xtask tests. The four nextest runs (the workspace without Workshop, the Workshop crates, workshop-workspace, and headless workshop-server) passed with 4,966, 311, 155, and 197 tests.
• For the five later plans, no test counts are recorded. Each plan record marks its verification todo completed.
  • For parallel tool calls, easy fixes, the tool-call cap, and its debt removal, that covers both nextest runs (with and without the Workshop crates), both clippy runs with warnings denied, the format check, the docs and facade docs builds, the facade API check, the build-xtask tests, and the docs-claims scan, at each plan's last step. Every step also ran its own focused tests.
  • For workshop waits, it covers the Workshop npm tests and typecheck, the docs-claims scan, and a check that each new test fails at 83d40b1b9, before the fix.
• Two exit searches print nothing: one for the old native and install wording in crates and AGENTS.md, and one for fn visible_sections, fn home_without, or Vec<Section> in non-test Engine code. A third, git grep -n "only a cancel" -- . ':(exclude)vibe', prints nothing after the drop-contract fix.
• The facade API check passes. crates/promptforge/public-api.txt changes only in the two lines the tool-call cap adds, EffectId's derives and Step::Pending::withdrawn. The other Host-facing changes sit in harness::plugin and promptforge-plugin, which that listing does not cover, and the new coroutine protocol variants are internal to the Lua crate.
• prompt_reads_resolve_over_the_visible_set runs one shared document and checks that prompt.section returns a section's own Markdown byte for byte (an indented first line, a lua fence, a thematic break, and {{ args }} included), that prompt.list returns child and numbered items in order, that an empty section reads "", and that a niece, a grandchild, the caller, and a missing heading read nil from both.
• prompt_reads_raise_only_for_mistakes_in_the_call pins each raise (a non-string, a bare name, no whitespace after the markers, and prompt.list on a prose or empty section), that misses do not raise, and that a call to a missing heading still lists only the visible sections. prompt_reads_work_in_h1_and_the_shared_library pins that H1 sees every top-level section and no child, and that a shared-library read resolves per VM at load time and per calling section from a shared function.
• section_markdown_is_the_sections_own_content pins the parser's Markdown span byte for byte, and find_visible_returns_none_for_an_address_not_in_the_set pins None for a missing name and for a level mismatch. The old list_from_section.rs test file and three other list_from_section tests are deleted. No test now drives an ambiguous heading through a read, though resolve_visible_rejects_more_than_one_match covers the shared lookup.
• The new registry integration tests pin the listing order and kinds, InvalidPackage and DuplicatePackage from add (the native's name included), UnknownPackage for promptforge/tasks, each ReservedName case and its message text, and NameTaken on a second native install. natives_offer_no_tools_prelude_or_needs fails if anyone gives a native tools, a prelude, or needs. Host tests check that an installed native meets a declared subagents and adds no catalog tool or prelude, and a Workshop test checks that a prompt declaring subagents runs on the server's installed Plugins.
• Three BodyText unit tests pin that a range reads back its text, that a string outside the shared text is refused, and that equal text from different ranges compares equal. Otherwise the existing read, addressing, jump, fanout, and parser suites serve as the in-place work's regression suite, edited only at call sites and in the expressions that build expected values.
• parallel_tool_calls.rs is new and steps a run by hand. a_rounds_catalog_calls_are_issued_in_one_step_and_append_in_call_order checks that two catalog calls issue in one step, c1 first, that answering c2 first issues nothing, and that the records still hold c1's result before c2's, both on the round's turn. a_local_call_or_a_task_builtin_runs_alone_between_its_neighbors covers both stop checks and a lone catalog call on the batch path, a_call_the_round_cannot_bind_stops_the_batch_and_raises_once_the_issued_calls_land pins the serial failure meaning, and cancelling_a_task_parked_on_a_batch_orphans_every_call pins that both in-flight calls are discarded after a cancel.
• two_calls_in_one_round_are_in_flight_at_once_and_a_stop_drops_both, in the Harness stop tests, waits until both calls are running, then stops the round and expects false:cancelled with both calls dropped. Under the old serial loop that wait never succeeds, so it is the end-to-end proof that the calls overlap. It still passes under the default cap of ten.
• The loop machine gains a_short_batch_answer_sends_the_next_call_alone_then_the_rest_together. The tests that answered the old single-call request after a model reply are rewritten for the batch request, and the existing one-call catalog rounds across the execute suite now run through the batch path as its regression suite.
• The tasks.fanout rename edits call sites in 25 test files and 5 fixture prompts. The error-text asserts now match the full new texts, because the old substrings also matched the new messages, and the two-way RESERVED_NAMES test checks that no fanout global is left.
• In Workshop, new service checks pin that two open waits pin the oldest and advance on each answer, that cancelling a newer wait keeps the oldest pinned, that a reattach resend pins the oldest unresolved wait, and that a sibling call's result leaves generating off and the wait pinned. A view check pins that the composer stays on Send. Four existing model-ask checks used to leave a wait open when a tool result landed, a state the shipped UI cannot reach, so they now cancel each wait first and keep their assertions.
• The easy fixes add no tests. The route refactor touches no test file, so the existing scheduler and Harness suites are its regression suite, and the parse-test split keeps every moved test's name and body.
• The Engine's parallel_tool_calls-withdrawn.rs steps a run by hand:
  • cancelling_a_task_withdraws_its_unanswered_tool_calls checks that the step that cancels lists both calls in effect-id order, and that earlier steps list none.
  • a_call_issued_and_withdrawn_in_one_step_is_listed_twice pins that one step can list a call in both effects and withdrawn.
  • one_step_lists_every_tasks_withdrawn_calls_in_effect_id_order cancels two tasks in reverse spawn order and expects the list sorted.
  • a_decided_run_lists_no_withdrawn_calls fails without the clear in end.
• The Harness's effect_loop-cap.rs drives runs with small caps. Each of its tests failed before the change it covers:
  • the_cap_holds_extra_calls_until_one_lands;
  • waiting_calls_start_oldest_first, where a later batch's call starts after an earlier batch's leftovers;
  • a_call_withdrawn_in_the_step_that_issued_it_never_starts, which fails if the Driver withdraws before queuing;
  • cancelling_a_task_drops_its_waiting_and_running_calls;
  • a_cancel_drops_waiting_calls_without_starting_them.
• harness-stop-cap.rs runs through Harness::run under the default cap of ten:
  • a_stop_drops_waiting_calls_without_starting_them runs 11 held calls, stops once 10 have started, and expects 10 starts, 10 teardowns, and 11 Dropped answers.
  • a_stop_starts_a_waiting_call_that_survives_stops checks that an operator question waiting behind 10 held calls is asked only after the stop frees their slots.
  • cancelling_a_task_drops_its_question_to_the_operator checks that cancelling a task tears down its open question while the run goes on to complete. It passes on the existing behavior by design, because it pins what the new docs promise. When a withdrawal was made to spare calls that survive stops, it failed on its 10-second timeout.