Advance independent work together
Independent work does not always need to wait in line. Wildo can run compatible methods together within a round and bring their results into the next decision.
Before admitting the work, it compares the artifact families the methods can write, including outputs of their composed children. This keeps a parent method and another writer of the same result from being selected together in that round.
Example — Keep parallel work from claiming the same result
Market research can contribute alongside unrelated work. But a market-analysis umbrella and its own snapshot producer both lead to the market snapshot, so the admission check keeps them apart.
For engineers
Include children in the scope
This selected runtime implementation walks admitted descendants as well as the parent:
const families = new Set<string>();
const unresolvedRefs: string[] = [];
const visited = new Set<string>();
const pending: string[] = [playbookRef];
while (pending.length > 0) {
const ref = pending.shift()!;
if (visited.has(ref)) continue;
visited.add(ref);
const playbook = playbooksByRef.get(ref);
if (playbook === undefined) {
unresolvedRefs.push(ref);
continue;
}
(playbook.outputs ?? []).forEach((output) => families.add(output.family));
pending.push(...(playbook.method?.choreography?.admits ?? []));
}
This is an excerpt from resolvePlaybookWriteScope, not an application extension point. A composite with outputs: [] is therefore not assumed to write nothing when its children produce artifacts.
Admit a compatible portfolio
The admission function walks proposed lanes in order. It holds back a later lane whose families overlap those already admitted and returns a reason for that decision. If a referenced child cannot be resolved, its scope is unknown: it can run alone, but is not treated as safe to combine with another lane.
The outer loop bounds its portfolio, and composites also bound child concurrency. Child results are collected before the next selection round.
| Execution boundary | Current behavior |
|---|---|
| Methods within a loop round | Bounded parallel execution with declared family-scope admission |
| Children within a composite | Bounded parallel execution and isolated child outcomes |
| Another unattended loop in the same companion | Refused while a loop is active |
| Coding workspace mutations | Serialized by the coding lane’s workspace lock |
Keep concurrency claims precise
This mechanism compares declared artifact outputs within the managed round. It is not a filesystem sandbox or a branch-and-merge service, and it does not turn unrelated manual writers into coordinated lanes.
Several independently managed, long-running choreographies with their own goals and merge lifecycle remain a distinct design target. The available mechanism is parallel work inside a controlled round; application authors should plan around that concrete boundary.