@zachwill/pi-orchestrate 0.4.2 → 0.4.3

package/README.md

@@ -28,7 +28,7 @@ Pi Orchestrate adds exactly five tools:
 
 Each `orchestrate` call validates its input, worker definition, and model before allocating IDs or starting a session. Calls are admitted independently: a rejected sibling does not block valid siblings. After admission, a startup or prompt failure settles only that worker as `failed`.
 
-Pi executes sibling tool calls concurrently, with no extension-level group limit or hidden throttle. Before yielding, send every known independent task as sibling `orchestrate` calls in one assistant message. Finish dispatching the whole wave without waiting for any sibling's acceptance or completion; if one call is emitted separately, continue dispatching the remaining known siblings.
+Pi executes sibling tool calls concurrently. There is no extension-level sibling-group cap or hidden throttle. Before yielding, spin up as many workers as needed for the full initial wave, covering every useful independent task and distinct validation perspective with sibling `orchestrate` calls in one assistant message. Finish dispatching that wave without waiting for any sibling's acceptance or completion; if one call is emitted separately, continue dispatching the rest of the wave.
 
 Execution mode depends on the complete tool-call group:
 
@@ -65,10 +65,10 @@ Workers, runs, and queued delivery survive extension reloads and session switche
 
 Pi Orchestrate injects the authoritative orchestration contract and trusted catalog into the parent system prompt. The parent remains responsible for the task end to end:
 
-1. Keep trivial or tightly coupled work in the parent. Divide broad work into bounded, independent scopes and dispatch all currently independent scopes in parallel.
-2. Give every worker a thorough, self-contained brief with the objective, paths and scope, context, success criteria, and expected output. State forbidden actions explicitly.
-3. Before yielding, dispatch every currently known independent scope. Never stop after one call while another known scope remains, and never wait for one sibling's acceptance or completion before dispatching the rest.
-4. As results expose new independent work, dispatch another parallel wave and continue until the whole task is complete.
+1. Keep trivial or tightly coupled work in the parent. For broad work, spin up as many workers as needed to cover every useful bounded independent scope and distinct validation perspective; never use a small default or the number of roles the user names. Named workers and counts are a floor unless the user explicitly states an exact cap; the same role can be instantiated for multiple scopes.
+2. Give every worker a thorough, self-contained brief with the objective, paths and scope, context, success criteria, and expected output. Distinct validation perspectives can intentionally overlap, but avoid accidental duplicate work. State forbidden actions explicitly.
+3. Before yielding, dispatch the full initial wave. Never stop after one call while another useful scope or perspective can run independently, and never wait for one sibling's acceptance or completion before dispatching the rest.
+4. As results expose new independent work, dispatch each full adaptive wave in parallel and continue until the whole task is complete.
 5. Review evidence and changes, resolve conflicts, integrate deliberately, and verify the result.
 6. Produce the final answer from the parent session.
 

package/extension/contract.ts

@@ -29,15 +29,17 @@ function buildContract(catalog: WorkerCatalog): string {
 
 You are the parent orchestrator and own the task end to end.
 
-- Keep trivial or tightly coupled work in the parent. Divide broad work into bounded, independent scopes and dispatch all currently independent scopes in parallel.
-- Before dispatching, finish enumerating the current parallel wave. Dispatch every currently known independent scope before yielding. Never stop after one \`orchestrate\` call while another known independent scope remains, and do not wait for one sibling's acceptance or completion before dispatching the rest.
-- Delegate each independent scope with its own \`orchestrate\` call using \`{ worker, title, instructions }\`. Emit sibling \`orchestrate\` calls in one assistant message so Pi executes them concurrently.
+- Keep trivial or tightly coupled work in the parent. For broad work, proactively identify every useful bounded independent scope and every materially distinct evidence, hypothesis, or validation perspective. Spin up as many workers as needed to cover them; never use a small fixed default.
+- Treat worker roles and counts named by the user as minimum requirements, not ceilings. Exceed them when additional useful independent scopes or materially distinct perspectives exist, unless the user explicitly sets an exact cap. A worker role is reusable: dispatch the same catalog worker in many calls when it fits separate scopes or perspectives.
+- Before dispatching, enumerate the full first parallel wave from the work itself. Dispatch that entire wave before yielding. Never stop after one \`orchestrate\` call while another useful scope or perspective can run independently, and do not wait for one sibling's acceptance or completion before dispatching the rest.
+- Delegate each independent scope or distinct perspective with its own \`orchestrate\` call using \`{ worker, title, instructions }\`. Emit the full wave of sibling \`orchestrate\` calls in one assistant message so Pi executes them concurrently.
+- Deliberate overlap is allowed only when calls pursue materially distinct evidence sources, competing hypotheses, or validation perspectives. Encode that distinction in each brief; accidental duplicate assignments are forbidden.
 - Give every worker a thorough, self-contained brief with the objective, paths and scope, context, success criteria, and expected output. State forbidden actions explicitly.
 - Input, catalog, and model preflight is atomic per call before that worker starts. Sibling calls are admitted independently, so one rejected call does not prevent valid siblings from starting.
 - A sole \`orchestrate\` call or a pure group of sibling \`orchestrate\` calls runs asynchronously. Pi accepts a pure group concurrently, yields the parent turn, delivers each result as it settles, and starts synthesis only after the whole group settles. Mixing \`orchestrate\` with another tool makes it inline and blocking. \`worker_send\` is asynchronous only as the sole tool call in its assistant message.
 - Exact worker instructions remain visible in the tool call and can be expanded; titles are labels, not substitutes for complete messages.
-- After every currently known sibling has been dispatched, yield the parent turn once their admissions have resolved; a rejected sibling does not block yielding. Worker responses arrive individually as each worker settles, and the final response starts parent synthesis. Do not duplicate delegated work, poll \`orchestration_status\`, or use it as a normal completion mechanism.
-- As results expose new independent work, dispatch another parallel wave. Continue until the whole task is complete.
+- After the full current wave has been dispatched, yield the parent turn once its admissions have resolved; a rejected sibling does not block yielding. Worker responses arrive individually as each worker settles, and the final response starts parent synthesis. Do not poll \`orchestration_status\` or use it as a normal completion mechanism.
+- As results expose more useful independent scopes or materially distinct perspectives, enumerate and dispatch another full parallel wave before yielding. Continue adaptive full waves until the whole task is complete.
 - The parent synthesizes worker results, reviews their evidence and changes, resolves conflicts, integrates the final result, and runs the relevant verification before declaring completion.
 - Prefer one-shot workers. Use \`worker_send\` for follow-up work on a ready reusable worker, \`worker_close\` when that ready worker is finished, and \`worker_abort\` only when active work must stop.
 - The public tools are \`orchestrate\`, \`orchestration_status\`, \`worker_send\`, \`worker_abort\`, and \`worker_close\`.

package/extension/tools.ts

@@ -111,11 +111,11 @@ export function registerOrchestrationTools(
     name: "orchestrate",
     label: "Orchestrate",
     description:
-      "Dispatch one fully briefed task. One or more sibling orchestrate calls run concurrently and asynchronously. Mixing orchestrate with another tool makes it inline and blocking.",
-    promptSnippet: "Dispatch one fully briefed worker task",
+      "Dispatch fully briefed worker scopes. Sibling orchestrate calls run concurrently and asynchronously. Mixing orchestrate with another tool makes it inline and blocking.",
+    promptSnippet: "Dispatch fully briefed parallel worker scopes",
     promptGuidelines: [
-      "Use sibling orchestrate calls for independent tasks, with one complete brief per call.",
-      "Before yielding, dispatch every currently known independent task; never wait for one sibling's acceptance or completion before dispatching the rest.",
+      "Spin up as many workers as needed to cover every useful parallel scope and distinct validation perspective. Treat user-named workers or counts as a floor unless explicitly capped, and reuse the same worker role across multiple calls when useful.",
+      "Give each call one complete brief, and emit all sibling orchestrate calls before yielding; never wait for one sibling's acceptance or completion before dispatching the rest.",
     ],
     executionMode: "parallel",
     parameters: orchestrateSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zachwill/pi-orchestrate",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "description": "Concurrent worker orchestration for Pi",
   "files": ["extension/", "examples/", "README.md", "LICENSE"],