@zachwill/pi-orchestrate 0.2.1 → 0.3.0

package/README.md

@@ -14,23 +14,23 @@ Pi packages execute with your system permissions. Review the package and worker
 
 Pi Orchestrate adds exactly five tools:
 
-- `orchestrate` dispatches 1–12 tasks with `orchestrate({ tasks: [{ worker, title, instructions }] })`.
-- `orchestration_status` inspects the trusted catalog, catalog diagnostics, waves, and worker states without exposing full task instructions.
+- `orchestrate` dispatches one task with `orchestrate({ worker, title, instructions })`. Send independent tasks as sibling `orchestrate` calls in the same assistant message.
+- `orchestration_status` inspects the trusted catalog, catalog diagnostics, runs, and worker states without exposing full task instructions.
 - `worker_send` sends follow-up instructions to an owned reusable worker in the `ready` state.
 - `worker_abort` stops owned active work that is no longer needed.
 - `worker_close` closes an owned reusable worker in the `ready` state.
 
-An `orchestrate` wave first performs atomic input, catalog, and model preflight. No worker starts if any task fails that preflight. After acceptance, worker resources start independently: a resource startup failure becomes that worker's `failed` result and does not roll back or stop its peers.
+Each `orchestrate` call first performs atomic input, catalog, and model preflight before its worker starts. Sibling calls are admitted independently: one rejected call does not prevent valid siblings from starting. After acceptance, a resource startup failure becomes that worker's `failed` result and does not roll back or stop sibling calls.
 
-All tasks in a wave execute concurrently, including a full 12-task wave. Pi Orchestrate applies no hidden concurrency throttle. Exact unchanged worker instructions remain visible in each tool call: collapsed calls preview every message, and expanded calls show every full brief. Titles are labels, never replacements for instructions.
+Pi executes sibling tool calls concurrently, so independent `orchestrate` calls start concurrently without an extension-level group limit or hidden throttle. Exact unchanged worker instructions remain visible in each tool call: collapsed calls preview the message, and expanded calls show the full brief. Titles are labels, never replacements for instructions.
 
-For asynchronous behavior, `orchestrate` or `worker_send` must be the sole tool call in its assistant message. Mixing either with any sibling tool call makes its wave inline and blocking. Inline work receives the parent turn's cancellation signal. Accepted async work does not retain that signal and continues independently.
+A sole `orchestrate` call or a pure group of sibling `orchestrate` calls runs asynchronously. Pi accepts a pure group concurrently and yields the parent turn. Mixing `orchestrate` with another tool makes it inline and blocking. `worker_send` is asynchronous only as the sole tool call in its assistant message. Inline work receives the parent turn's cancellation signal. Accepted async work does not retain that signal and continues independently.
 
-A successful async call yields the parent turn. Responses enter the transcript individually as workers settle, and the final response starts the parent's synthesis turn. The bottom widget is ephemeral and shows active work only; completed, failed, aborted, and reusable ready workers disappear immediately. Inline responses accumulate in the live tool output while the call blocks.
+Async worker responses enter the transcript individually as workers finish. An ungrouped response starts the parent's synthesis turn. Responses from sibling calls share one final synthesis turn. The bottom widget is ephemeral and shows active work only; completed, failed, aborted, and reusable ready workers disappear immediately. An inline call shows its single current response in the live tool output while it blocks.
 
 `orchestration_status` is for diagnostics and recovery, never a normal completion mechanism. Do not poll it for completion. If the owning session becomes inactive, its workers continue and completed results remain queued. Those results become available only when that exact owning session resumes; they are never delivered to another session.
 
-Worker IDs identify live worker sessions. A reusable worker keeps the same worker ID across `worker_send` follow-ups, with each follow-up result belonging to a new wave. One-shot workers finish as `completed`. Reusable workers deliver as `ready` and wait for `worker_send` or `worker_close`. Use `worker_abort` only for active work, not to close a ready worker.
+Each run owns exactly one worker generation. Worker IDs identify live worker sessions. A reusable worker keeps the same worker ID across `worker_send` follow-ups, with each follow-up result belonging to a new run. One-shot workers finish as `completed`. Reusable workers deliver as `ready`, remain available for follow-up, and wait for `worker_send` or `worker_close`. Use `worker_abort` only for active work by `worker_ids` or `all`, not to close a ready worker.
 
 ## Parent orchestration contract
 
@@ -38,8 +38,8 @@ Pi Orchestrate automatically injects the authoritative orchestration contract an
 
 1. Keep trivial or tightly coupled work in the parent session.
 2. Give every delegated task a full brief: objective, paths and scope, forbidden actions, context, constraints, observable success, checks, and expected output.
-3. Dispatch every known independent task in one `orchestrate` wave, up to 12 tasks.
-4. Make an async `orchestrate` or `worker_send` call the sole tool call in its assistant message, then yield after acceptance.
+3. Dispatch every known independent task with a sibling `orchestrate` call in the same assistant message.
+4. Keep an async `orchestrate` call or pure sibling group separate from other tools, then yield after acceptance. Make `worker_send` the sole tool call when it should run asynchronously.
 5. Review delivered evidence and changes, resolve conflicts, integrate deliberately, and run the relevant verification.
 6. Deliver the final answer from the parent session.
 

package/extension/catalog.ts

@@ -13,7 +13,11 @@ import type {
   WorkerDefinition,
   WorkerSourceKind,
 } from "./domain.js";
-import { isSupportedToolName, SUPPORTED_TOOL_NAMES } from "./domain.js";
+import {
+  createWorkerCatalog,
+  isSupportedToolName,
+  SUPPORTED_TOOL_NAMES,
+} from "./domain.js";
 
 const MAX_WORKER_BYTES = 64 * 1024;
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
@@ -127,27 +131,34 @@ function isMissingPath(error: unknown): boolean {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
-interface UnexpectedPath {
+interface IssuePath {
   readonly path: readonly PropertyKey[];
+  readonly issue: SchemaIssue.Issue;
 }
 
-function collectUnexpectedPaths(
+function collectIssuePaths(
   issue: SchemaIssue.Issue,
   parentPath: readonly PropertyKey[] = [],
-): UnexpectedPath[] {
+): IssuePath[] {
   switch (issue._tag) {
     case "Pointer":
-      return collectUnexpectedPaths(issue.issue, [...parentPath, ...issue.path]);
+      return collectIssuePaths(issue.issue, [...parentPath, ...issue.path]);
     case "Composite":
+      return issue.issues.flatMap((child) => collectIssuePaths(child, parentPath));
     case "AnyOf":
-      return issue.issues.flatMap((child) => collectUnexpectedPaths(child, parentPath));
+      return issue.issues.length === 0
+        ? [{ path: parentPath, issue }]
+        : issue.issues.flatMap((child) => collectIssuePaths(child, parentPath));
     case "Encoding":
     case "Filter":
-      return collectUnexpectedPaths(issue.issue, parentPath);
+      return collectIssuePaths(issue.issue, parentPath);
+    case "InvalidType":
+    case "InvalidValue":
+    case "MissingKey":
     case "UnexpectedKey":
-      return [{ path: parentPath }];
-    default:
-      return [];
+    case "Forbidden":
+    case "OneOf":
+      return [{ path: parentPath, issue }];
   }
 }
 
@@ -165,8 +176,9 @@ function listItems(value: unknown): readonly unknown[] {
   return Array.isArray(value) ? value : [];
 }
 
-function schemaDiagnostic(error: Schema.SchemaError, frontmatter: unknown): string {
-  const unexpected = collectUnexpectedPaths(error.issue);
+function schemaDiagnostic(issue: SchemaIssue.Issue, frontmatter: unknown): string {
+  const issuePaths = collectIssuePaths(issue);
+  const unexpected = issuePaths.filter(({ issue }) => issue._tag === "UnexpectedKey");
   const frontmatterFields = unexpected
     .filter(({ path }) => path.length === 1 && typeof path[0] === "string")
     .map(({ path }) => String(path[0]))
@@ -196,8 +208,9 @@ function schemaDiagnostic(error: Schema.SchemaError, frontmatter: unknown): stri
     "compaction",
     "lifecycle",
   ];
-  const message = error.message;
-  const field = orderedFields.find((candidate) => message.includes(`["${candidate}"]`));
+  const field = orderedFields.find((candidate) =>
+    issuePaths.some(({ path }) => path[0] === candidate)
+  );
   const value = field === undefined ? undefined : fieldValue(frontmatter, field);
 
   if (field === "name" || field === "description") {
@@ -234,13 +247,21 @@ function schemaDiagnostic(error: Schema.SchemaError, frontmatter: unknown): stri
     if (compactionFields.length > 0) {
       return `unknown compaction field${compactionFields.length === 1 ? "" : "s"}: ${compactionFields.join(", ")}`;
     }
-    if (message.includes('["enabled"]')) {
+    if (issuePaths.some(({ path }) => path[0] === "compaction" && path[1] === "enabled")) {
       return "frontmatter field 'compaction.enabled' must be a boolean";
     }
-    if (message.includes('["reserveTokens"]')) {
+    if (
+      issuePaths.some(({ path }) =>
+        path[0] === "compaction" && path[1] === "reserveTokens"
+      )
+    ) {
       return "frontmatter field 'compaction.reserveTokens' must be a non-negative integer";
     }
-    if (message.includes('["keepRecentTokens"]')) {
+    if (
+      issuePaths.some(({ path }) =>
+        path[0] === "compaction" && path[1] === "keepRecentTokens"
+      )
+    ) {
       return "frontmatter field 'compaction.keepRecentTokens' must be a non-negative integer";
     }
     return "frontmatter field 'compaction' must be a mapping";
@@ -266,7 +287,7 @@ function parseWorker(
   const { frontmatter, body } = parsed;
   const decoded = decodeWorkerFrontmatter(frontmatter);
   if (Result.isFailure(decoded)) {
-    throw new Error(schemaDiagnostic(decoded.failure, frontmatter));
+    throw new Error(schemaDiagnostic(decoded.failure.issue, frontmatter));
   }
 
   const worker = decoded.success;
@@ -381,10 +402,7 @@ export function createWorkerCatalogDiscovery(fileSystem: CatalogFileSystem) {
       diagnostics.push(...discovered.diagnostics);
     }
 
-    const workers = [...workersByName.values()].sort((left, right) =>
-      compareText(left.name, right.name),
-    );
-    return { workers, diagnostics };
+    return createWorkerCatalog([...workersByName.values()], diagnostics);
   };
 }
 

package/extension/contract.ts

@@ -30,12 +30,12 @@ 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. Use as many useful workers as independent scopes justify.
-- Delegate every known independent scope in one concurrent \`orchestrate\` wave with \`{ tasks: [{ worker, title, instructions }] }\`. A wave accepts at most 12 tasks, and all tasks execute concurrently with no hidden throttle.
+- 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.
 - Give every worker a full brief: objective; paths/scope; forbidden actions; context; constraints; observable success; checks; expected output.
-- Input, catalog, and model preflight is atomic before any worker starts. Resource startup failures become per-worker failed results and do not roll back peers.
-- For asynchronous behavior, \`orchestrate\` or \`worker_send\` must be the sole tool call in its assistant message. Mixing either with any sibling tool call makes its wave inline and blocking.
+- 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 an accepted async wave, yield the parent turn. 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.
+- After an accepted async run, yield the parent turn. 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.
 - The active-work widget shows only workers currently starting, running, or stopping. Inline worker responses appear progressively in live tool output.
 - 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.

package/extension/delivery.ts

@@ -35,10 +35,17 @@ interface BoundParent {
   agentRunning: boolean;
 }
 
+interface SynthesisGroupState {
+  expected: number;
+  readonly acceptedEventIds: string[];
+}
+
 export class DeliveryCoordinator {
   private readonly boundParents = new Map<string, BoundParent>();
   private readonly pendingSettlements: WorkerSettlement[] = [];
   private readonly flushingOwners = new Set<string>();
+  private readonly synthesisGroups = new Map<string, SynthesisGroupState>();
+  private readonly finalSynthesisGroupEvents = new Set<string>();
   private highestAcceptedSequence = 0;
 
   bind(binding: ParentBinding): void {
@@ -75,12 +82,28 @@ export class DeliveryCoordinator {
 
     this.highestAcceptedSequence = settlement.sequence;
     this.pendingSettlements.push(settlement);
+    this.acceptSynthesisGroupSettlement(settlement);
 
     const parent = this.boundParents.get(settlement.ownerSessionId);
     if (parent) this.flush(settlement.ownerSessionId, parent.binding.generation);
     return true;
   }
 
+  skipSynthesisGroupMember(
+    ownerSessionId: string,
+    synthesisGroupId: string,
+    synthesisGroupSize: number,
+  ): void {
+    const key = synthesisGroupKey(ownerSessionId, synthesisGroupId);
+    const state = this.synthesisGroups.get(key) ?? {
+      expected: synthesisGroupSize,
+      acceptedEventIds: [],
+    };
+    state.expected = Math.max(0, state.expected - 1);
+    this.synthesisGroups.set(key, state);
+    this.refreshSynthesisGroupBoundary(key, state);
+  }
+
   pendingCount(ownerSessionId: string): number {
     return this.pendingSettlements.filter(
       (settlement) => settlement.ownerSessionId === ownerSessionId,
@@ -91,13 +114,11 @@ export class DeliveryCoordinator {
     this.boundParents.clear();
     this.pendingSettlements.length = 0;
     this.flushingOwners.clear();
+    this.synthesisGroups.clear();
+    this.finalSynthesisGroupEvents.clear();
     this.highestAcceptedSequence = 0;
   }
 
-  close(): void {
-    this.clear();
-  }
-
   private matchesBinding(
     ownerSessionId: string,
     generation: ParentBindingGeneration,
@@ -127,7 +148,8 @@ export class DeliveryCoordinator {
       );
       let latestFinalIndex = -1;
       for (let index = 0; index < queued.length; index += 1) {
-        if (queued[index]?.waveComplete) latestFinalIndex = index;
+        const settlement = queued[index];
+        if (settlement && this.isFinalBoundary(settlement)) latestFinalIndex = index;
       }
       const flushThrough = latestFinalIndex >= 0 ? latestFinalIndex : queued.length - 1;
       let flushBytesRemaining = MAX_DELIVERY_MARKDOWN_BYTES;
@@ -139,13 +161,9 @@ export class DeliveryCoordinator {
 
         const messagesRemaining = flushThrough - index + 1;
         const fairFlushBytes = Math.floor(flushBytesRemaining / messagesRemaining);
-        const fairWaveBytes = Math.floor(
-          MAX_DELIVERY_MARKDOWN_BYTES / Math.max(1, settlement.waveSize),
-        );
         const byteLimit = Math.max(0, Math.min(
           MAX_WORKER_DELIVERY_MARKDOWN_BYTES,
           fairFlushBytes,
-          fairWaveBytes,
           flushBytesRemaining,
         ));
         const triggerTurn = latestFinalIndex >= 0 && index === flushThrough;
@@ -165,6 +183,7 @@ export class DeliveryCoordinator {
         if (pendingIndex >= 0) this.pendingSettlements.splice(pendingIndex, 1);
 
         if (triggerTurn) {
+          this.finishSynthesisGroup(settlement);
           parent.agentRunning = true;
           return;
         }
@@ -178,17 +197,17 @@ export class DeliveryCoordinator {
     settlement: WorkerSettlement,
     byteLimit: number,
   ): WorkerDeliveryMessage {
-    const heading = `## Worker result — ${settlement.worker}`;
+    const heading = `## Worker result — ${settlement.title} · ${settlement.worker}`;
     const metadata = [
       `Worker \`${settlement.workerId}\``,
-      `wave \`${settlement.waveId}\``,
+      `run \`${settlement.runId}\``,
       `status \`${settlement.status}\``,
     ].join(" · ");
     const body = renderOutcome(settlement.outcome);
     const content = body.length > 0
-      ? `${heading}\n\n### ${settlement.title}\n${metadata}\n\n${body}`
-      : `${heading}\n\n### ${settlement.title}\n${metadata}`;
-    const appendix = settlement.waveComplete
+      ? `${heading}\n\n${metadata}\n\n${body}`
+      : `${heading}\n\n${metadata}`;
+    const appendix = this.isFinalBoundary(settlement)
       ? `\n\n---\n\n${DELIVERY_PARENT_INSTRUCTIONS}`
       : "";
 
@@ -199,6 +218,45 @@ export class DeliveryCoordinator {
       details: settlement,
     });
   }
+
+  private acceptSynthesisGroupSettlement(settlement: WorkerSettlement): void {
+    if (!settlement.synthesisGroupId || !settlement.synthesisGroupSize) return;
+    const key = synthesisGroupKey(settlement.ownerSessionId, settlement.synthesisGroupId);
+    const state = this.synthesisGroups.get(key) ?? {
+      expected: settlement.synthesisGroupSize,
+      acceptedEventIds: [],
+    };
+    state.acceptedEventIds.push(settlement.eventId);
+    this.synthesisGroups.set(key, state);
+    this.refreshSynthesisGroupBoundary(key, state);
+  }
+
+  private refreshSynthesisGroupBoundary(key: string, state: SynthesisGroupState): void {
+    if (state.expected === 0) {
+      this.synthesisGroups.delete(key);
+      return;
+    }
+    if (state.acceptedEventIds.length !== state.expected) return;
+    const finalEventId = state.acceptedEventIds.at(-1);
+    if (finalEventId) this.finalSynthesisGroupEvents.add(finalEventId);
+  }
+
+  private isFinalBoundary(settlement: WorkerSettlement): boolean {
+    if (!settlement.synthesisGroupId) return true;
+    return this.finalSynthesisGroupEvents.has(settlement.eventId);
+  }
+
+  private finishSynthesisGroup(settlement: WorkerSettlement): void {
+    if (!settlement.synthesisGroupId) return;
+    this.synthesisGroups.delete(
+      synthesisGroupKey(settlement.ownerSessionId, settlement.synthesisGroupId),
+    );
+    this.finalSynthesisGroupEvents.delete(settlement.eventId);
+  }
+}
+
+function synthesisGroupKey(ownerSessionId: string, synthesisGroupId: string): string {
+  return `${ownerSessionId}\u0000${synthesisGroupId}`;
 }
 
 function capMarkdown(content: string, appendix: string, byteLimit: number): string {
@@ -238,7 +296,5 @@ function renderOutcome(outcome: WorkerSettlement["outcome"]): string {
       const reason = outcome.message ? `Aborted: ${outcome.message}` : "Aborted";
       return outcome.assistantText ? `${reason}\n\n${outcome.assistantText}` : reason;
     }
-    case "closed":
-      return "Closed";
   }
 }

package/extension/domain.ts

@@ -95,17 +95,17 @@ export interface OrchestrateTaskInput {
 }
 
 declare const workerIdBrand: unique symbol;
-declare const waveIdBrand: unique symbol;
+declare const runIdBrand: unique symbol;
 
 export type WorkerId = string & { readonly [workerIdBrand]: "WorkerId" };
-export type WaveId = string & { readonly [waveIdBrand]: "WaveId" };
+export type RunId = string & { readonly [runIdBrand]: "RunId" };
 
 export type WorkerIdFactory = () => WorkerId;
-export type WaveIdFactory = () => WaveId;
+export type RunIdFactory = () => RunId;
 
 export interface OrchestrateIdFactories {
   readonly workerId: WorkerIdFactory;
-  readonly waveId: WaveIdFactory;
+  readonly runId: RunIdFactory;
 }
 
 export function createRandomWorkerIdFactory(
@@ -114,10 +114,10 @@ export function createRandomWorkerIdFactory(
   return () => `worker-${randomId()}` as WorkerId;
 }
 
-export function createRandomWaveIdFactory(
+export function createRandomRunIdFactory(
   randomId: () => string = defaultRandomId,
-): WaveIdFactory {
-  return () => `wave-${randomId()}` as WaveId;
+): RunIdFactory {
+  return () => `run-${randomId()}` as RunId;
 }
 
 export function createRandomIdFactories(
@@ -125,7 +125,7 @@ export function createRandomIdFactories(
 ): OrchestrateIdFactories {
   return {
     workerId: createRandomWorkerIdFactory(randomId),
-    waveId: createRandomWaveIdFactory(randomId),
+    runId: createRandomRunIdFactory(randomId),
   };
 }
 
@@ -134,15 +134,15 @@ export function createSequentialWorkerIdFactory(startAt = 1): WorkerIdFactory {
   return () => `worker-${next++}` as WorkerId;
 }
 
-export function createSequentialWaveIdFactory(startAt = 1): WaveIdFactory {
+export function createSequentialRunIdFactory(startAt = 1): RunIdFactory {
   let next = startAt;
-  return () => `wave-${next++}` as WaveId;
+  return () => `run-${next++}` as RunId;
 }
 
 export function createSequentialIdFactories(startAt = 1): OrchestrateIdFactories {
   return {
     workerId: createSequentialWorkerIdFactory(startAt),
-    waveId: createSequentialWaveIdFactory(startAt),
+    runId: createSequentialRunIdFactory(startAt),
   };
 }
 
@@ -205,7 +205,6 @@ export type WorkerOutcome =
   | WorkerFailedOutcome
   | WorkerAbortedOutcome
   | WorkerClosedOutcome;
-export type TerminalWorkerOutcome = Exclude<WorkerOutcome, WorkerReadyOutcome>;
 export type WorkerStatus =
   | "starting"
   | "running"
@@ -219,13 +218,12 @@ export type TerminalWorkerStatus = Extract<
   WorkerStatus,
   "completed" | "failed" | "aborted" | "closed"
 >;
-export type WaveCompleteWorkerStatus = TerminalWorkerStatus | "ready";
 
 export interface WorkerRecord {
   readonly id: WorkerId;
   readonly worker: string;
   readonly ownerSessionId: string;
-  readonly waveId: WaveId;
+  readonly runId: RunId;
   readonly title: string;
   readonly instructions: string;
   readonly lifecycle: WorkerLifecycle;
@@ -239,16 +237,18 @@ export interface WorkerRecord {
   readonly sessionFile?: string;
 }
 
-export type WaveMode = "async" | "inline";
-export type WaveState = "running" | "complete";
+export type RunMode = "async" | "inline";
+export type RunState = "running" | "complete";
 
-export interface WaveRecord {
-  readonly id: WaveId;
+export interface RunRecord {
+  readonly id: RunId;
   readonly ownerSessionId: string;
-  readonly workerIds: readonly WorkerId[];
-  readonly mode: WaveMode;
-  readonly state: WaveState;
+  readonly workerId: WorkerId;
+  readonly mode: RunMode;
+  readonly state: RunState;
   readonly createdAt: number;
+  readonly synthesisGroupId?: string;
+  readonly synthesisGroupSize?: number;
 }
 
 export class InvalidTransitionError extends Error {
@@ -267,10 +267,6 @@ export function isTerminalWorkerStatus(status: WorkerStatus): status is Terminal
   return status === "completed" || status === "failed" || status === "aborted" || status === "closed";
 }
 
-export function isTerminalWorkerOutcome(outcome: WorkerOutcome): outcome is TerminalWorkerOutcome {
-  return outcome.status !== "ready";
-}
-
 export function canTransitionWorkerStatus(
   from: WorkerStatus,
   to: WorkerStatus,
@@ -306,36 +302,6 @@ export function transitionWorkerStatus(
   return { ...worker, status, outcome: undefined };
 }
 
-export function isWorkerCompleteForWave(
-  status: WorkerStatus,
-): status is WaveCompleteWorkerStatus {
-  return status === "ready" || isTerminalWorkerStatus(status);
-}
-
-export function getWaveWorkersInOrder(
-  wave: WaveRecord,
-  workersById: ReadonlyMap<WorkerId, WorkerRecord>,
-): readonly WorkerRecord[] | undefined {
-  const workers: WorkerRecord[] = [];
-
-  for (const workerId of wave.workerIds) {
-    const worker = workersById.get(workerId);
-    if (!worker) return undefined;
-    workers.push(worker);
-  }
-
-  return workers;
-}
-
-export function isWaveComplete(
-  wave: WaveRecord,
-  workersById: ReadonlyMap<WorkerId, WorkerRecord>,
-): boolean {
-  const workers = getWaveWorkersInOrder(wave, workersById);
-  return workers !== undefined && workers.every((worker) => isWorkerCompleteForWave(worker.status));
-}
-
-export const MAX_TASKS_PER_WAVE = 12;
 export const MAX_WORKER_TITLE_LENGTH = 200;
 export const MAX_WORKER_INSTRUCTIONS_LENGTH = 100_000;
 export const CANCELLATION_GRACE_MS = 5_000;

package/extension/host.ts

@@ -5,8 +5,7 @@ import {
 } from "./runtime.js";
 import { createWorkerSessionFactory } from "./worker-session.js";
 
-const PROCESS_HOST_KEY = Symbol.for("@zachwill/pi-orchestrate/process-host/v2");
-const LEGACY_PROCESS_HOST_KEY = Symbol.for("@zachwill/pi-orchestrate/process-host/v1");
+const PROCESS_HOST_KEY = Symbol.for("@zachwill/pi-orchestrate/process-host/v3");
 
 export interface ProcessHost {
   readonly runtime: OrchestratorRuntime;
@@ -26,14 +25,8 @@ interface OwnedProcessHost extends AttachmentAwareProcessHost {
   destroyPromise?: Promise<void>;
 }
 
-interface LegacyProcessHost extends ProcessHost {
-  unsubscribeCompletion?: () => void;
-  unsubscribeSettlement?: () => void;
-}
-
 type ProcessGlobal = typeof globalThis & {
   [PROCESS_HOST_KEY]?: OwnedProcessHost;
-  [LEGACY_PROCESS_HOST_KEY]?: LegacyProcessHost;
 };
 
 function processGlobal(): ProcessGlobal {
@@ -49,8 +42,6 @@ export function createProcessHost(): ProcessHost {
   const existing = global[PROCESS_HOST_KEY];
   if (existing) return existing;
 
-  retireLegacyProcessHost(global);
-
   const runtime = createOrchestratorRuntime({
     workerSessionFactory: createWorkerSessionFactory(),
   });
@@ -114,30 +105,3 @@ export async function quitProcessHost(): Promise<void> {
   if (!host) return;
   await destroyProcessHost(host);
 }
-
-function retireLegacyProcessHost(global: ProcessGlobal): void {
-  const legacy = global[LEGACY_PROCESS_HOST_KEY];
-  if (!legacy) return;
-
-  delete global[LEGACY_PROCESS_HOST_KEY];
-  try {
-    legacy.unsubscribeCompletion?.();
-  } catch {
-    // A stale subscription cannot prevent installation of the current host.
-  }
-  try {
-    legacy.unsubscribeSettlement?.();
-  } catch {
-    // A stale subscription cannot prevent installation of the current host.
-  }
-  try {
-    legacy.delivery.close();
-  } catch {
-    // Legacy delivery cleanup is best-effort during reload migration.
-  }
-  try {
-    void legacy.runtime.shutdown().catch(() => undefined);
-  } catch {
-    // Legacy runtime shutdown is best-effort during reload migration.
-  }
-}