@zachwill/pi-orchestrate 0.9.0 → 0.9.2

package/extension/contract.ts

@@ -11,6 +11,12 @@ function sortedWorkers(catalog: WorkerCatalog) {
   });
 }
 
+function escapeContractMarkers(value: string): string {
+  return value
+    .replaceAll(CONTRACT_START, "<!-- pi-orchestrate:contract:start -->")
+    .replaceAll(CONTRACT_END, "<!-- pi-orchestrate:contract:end -->");
+}
+
 function formatCatalog(catalog: WorkerCatalog): string {
   const workers = sortedWorkers(catalog);
   if (workers.length === 0) return "- No trusted workers are available for this session.";
@@ -18,11 +24,74 @@ function formatCatalog(catalog: WorkerCatalog): string {
   return workers
     .map(
       (worker) =>
-        `- \`${worker.name}\` [${worker.source.kind}] (${worker.lifecycle}): ${worker.description}`,
+        `- \`${escapeContractMarkers(worker.name)}\` [${worker.source.kind}] (${worker.lifecycle}): ${escapeContractMarkers(worker.description)}`,
     )
     .join("\n");
 }
 
+interface ContractMarker {
+  readonly start: number;
+  readonly end: number;
+  readonly kind: "start" | "end";
+}
+
+function contractMarkers(prompt: string): ContractMarker[] {
+  const markers: ContractMarker[] = [];
+  for (const [value, kind] of [
+    [CONTRACT_START, "start"],
+    [CONTRACT_END, "end"],
+  ] as const) {
+    let offset = 0;
+    while (offset < prompt.length) {
+      const start = prompt.indexOf(value, offset);
+      if (start < 0) break;
+      markers.push({ start, end: start + value.length, kind });
+      offset = start + value.length;
+    }
+  }
+  return markers.sort((left, right) => left.start - right.start);
+}
+
+function removeContractMarkers(prompt: string): {
+  readonly prompt: string;
+  readonly insertionOffset?: number;
+} {
+  const markers = contractMarkers(prompt);
+  if (markers.length === 0) return { prompt };
+
+  const removed: Array<{ start: number; end: number }> = [];
+  const stack: ContractMarker[] = [];
+  for (const marker of markers) {
+    if (marker.kind === "start") {
+      stack.push(marker);
+      continue;
+    }
+    const start = stack.pop();
+    if (start && stack.length === 0) removed.push({ start: start.start, end: marker.end });
+  }
+
+  for (const marker of markers) {
+    if (!removed.some((range) => marker.start >= range.start && marker.end <= range.end)) {
+      removed.push({ start: marker.start, end: marker.end });
+    }
+  }
+  removed.sort((left, right) => left.start - right.start);
+
+  const insertionPoint = markers[0]!.start;
+  let insertionOffset = 0;
+  let cursor = 0;
+  let cleaned = "";
+  for (const range of removed) {
+    if (range.start < cursor) continue;
+    const retained = prompt.slice(cursor, range.start);
+    cleaned += retained;
+    if (range.start <= insertionPoint) insertionOffset = cleaned.length;
+    cursor = range.end;
+  }
+  cleaned += prompt.slice(cursor);
+  return { prompt: cleaned, insertionOffset };
+}
+
 function buildContract(catalog: WorkerCatalog): string {
   return `${CONTRACT_START}
 ## Pi Orchestrate Contract
@@ -60,12 +129,9 @@ export function appendOrchestratorContract(
   catalog: WorkerCatalog,
 ): string {
   const section = buildContract(catalog);
-  const start = systemPrompt.indexOf(CONTRACT_START);
-  if (start >= 0) {
-    const end = systemPrompt.indexOf(CONTRACT_END, start);
-    if (end >= 0) {
-      return `${systemPrompt.slice(0, start)}${section}${systemPrompt.slice(end + CONTRACT_END.length)}`;
-    }
+  const cleaned = removeContractMarkers(systemPrompt);
+  if (cleaned.insertionOffset !== undefined) {
+    return `${cleaned.prompt.slice(0, cleaned.insertionOffset)}${section}${cleaned.prompt.slice(cleaned.insertionOffset)}`;
   }
 
   const separator =

package/extension/delivery.ts

@@ -67,6 +67,8 @@ export class DeliveryCoordinator implements DeliveryService {
   private readonly pendingSettlements: WorkerSettlement[] = [];
   private readonly flushingOwners = new Set<string>();
   private readonly synthesisGroups = new Map<string, SynthesisGroupState>();
+  // Runtime settlement sequences are process-scoped and monotonic across owners,
+  // so one watermark is valid.
   private highestAcceptedSequence = 0;
 
   bind(binding: ParentBinding): void {
@@ -83,15 +85,14 @@ export class DeliveryCoordinator implements DeliveryService {
   }
 
   markAgentStarted(ownerSessionId: string, generation: ParentBindingGeneration): void {
-    if (!this.matchesBinding(ownerSessionId, generation)) return;
     const parent = this.boundParents.get(ownerSessionId);
-    if (parent) parent.agentRunning = true;
+    if (parent?.binding.generation !== generation) return;
+    parent.agentRunning = true;
   }
 
   markAgentSettled(ownerSessionId: string, generation: ParentBindingGeneration): void {
-    if (!this.matchesBinding(ownerSessionId, generation)) return;
     const parent = this.boundParents.get(ownerSessionId);
-    if (!parent) return;
+    if (parent?.binding.generation !== generation) return;
     parent.agentRunning = false;
     this.flush(ownerSessionId, generation);
   }
@@ -163,21 +164,23 @@ export class DeliveryCoordinator implements DeliveryService {
 
     this.flushingOwners.add(ownerSessionId);
     try {
+      // Deliver a stable owner-ordered prefix, stopping at the latest complete synthesis boundary.
       const queued = this.pendingSettlements.filter(
         (settlement) => settlement.ownerSessionId === ownerSessionId,
       );
       let latestFinalIndex = -1;
-      for (let index = 0; index < queued.length; index += 1) {
-        const settlement = queued[index];
-        if (settlement && this.isFinalBoundary(settlement)) latestFinalIndex = index;
+      for (const [index, settlement] of queued.entries()) {
+        if (this.isFinalBoundary(settlement)) latestFinalIndex = index;
       }
       const flushThrough = latestFinalIndex >= 0 ? latestFinalIndex : queued.length - 1;
       let flushBytesRemaining = MAX_DELIVERY_MARKDOWN_BYTES;
 
-      for (let index = 0; index <= flushThrough; index += 1) {
+      for (const [index, settlement] of queued.entries()) {
+        if (index > flushThrough) break;
+        // Synchronous delivery callbacks can change owner, generation, or idle
+        // state before the next send.
         if (!this.canDeliver(ownerSessionId, generation)) return;
-        const settlement = queued[index];
-        if (!settlement || !this.pendingSettlements.includes(settlement)) continue;
+        if (!this.pendingSettlements.includes(settlement)) continue;
 
         const messagesRemaining = flushThrough - index + 1;
         const fairFlushBytes = Math.floor(flushBytesRemaining / messagesRemaining);
@@ -186,6 +189,8 @@ export class DeliveryCoordinator implements DeliveryService {
           fairFlushBytes,
           flushBytesRemaining,
         ));
+        // Intermediate results add context; only the completed boundary
+        // transfers work to a parent turn.
         const triggerTurn = latestFinalIndex >= 0 && index === flushThrough;
         const message = this.renderWorkerMessage(settlement, byteLimit);
         const parent = this.boundParents.get(ownerSessionId);
@@ -194,6 +199,7 @@ export class DeliveryCoordinator implements DeliveryService {
         try {
           parent.binding.sendMessage(message, { triggerTurn });
         } catch {
+          // Keep this settlement and the remaining prefix queued for a later retry.
           return;
         }
 

package/extension/host.ts

@@ -79,7 +79,7 @@ interface AttachmentAwareProcessHost extends ProcessHost {
   attachments?: Set<ProcessHostAttachment>;
 }
 
-type ProcessHostLifecycle = "active" | "destroying" | "destroyed";
+type ProcessHostLifecycle = "destroying" | "destroyed";
 
 interface OwnedProcessHost extends AttachmentAwareProcessHost {
   readonly effectRuntime?: ManagedRuntime.ManagedRuntime<Orchestration | Delivery, never>;
@@ -254,11 +254,9 @@ export function createProcessHost(): ProcessHost {
     throw new Error("Cannot create a process host while the current host is being destroyed");
   }
   if (existing?.lifecycle === "destroyed") {
-    delete global[PROCESS_HOST_KEY];
-  } else if (existing) {
-    existing.lifecycle = "active";
-    return existing;
+    throw new Error("Cannot create a process host after the current host was destroyed");
   }
+  if (existing) return existing;
 
   const effectRuntime = ManagedRuntime.make(createProcessApplicationLayer());
   const runtime = createProcessHostRuntimeAdapter(effectRuntime);
@@ -268,7 +266,6 @@ export function createProcessHost(): ProcessHost {
     delivery,
     effectRuntime,
     attachments: new Set(),
-    lifecycle: "active",
   };
   global[PROCESS_HOST_KEY] = host;
   return host;
@@ -304,7 +301,6 @@ export function destroyProcessHost(
   const ownedHost = host as OwnedProcessHost;
   if (ownedHost.destroyPromise) return ownedHost.destroyPromise;
   if ((ownedHost.attachments?.size ?? 0) > 0) return Promise.resolve();
-  if (ownedHost.lifecycle === "destroyed") return Promise.resolve();
 
   ownedHost.lifecycle = "destroying";
   let resolveDestruction!: () => void;

package/extension/index.ts

@@ -57,7 +57,6 @@ export function createOrchestrationExtension(
     let host: ProcessHost | undefined;
     let hostAttachment: ProcessHostAttachment | undefined;
     let statusController: StatusController | undefined;
-    let toolsRegistered = false;
     let activeBinding: OwnerBinding | undefined;
     let cachedCatalog: WorkerCatalog | undefined;
 
@@ -76,27 +75,16 @@ export function createOrchestrationExtension(
     registerOrchestrationPresentation(pi);
 
     pi.on("session_start", (_event, ctx) => {
-      if (activeBinding && host && statusController) {
-        host.delivery.unbind(
-          activeBinding.ownerSessionId,
-          activeBinding.generation,
-        );
-        statusController.unbind(activeBinding.ownerSessionId);
-      }
-
       host ??= dependencies.getHost?.() ?? createProcessHost();
       statusController ??=
         dependencies.createStatusController?.(host.runtime) ??
         createStatusController(host.runtime);
-      if (!toolsRegistered) {
-        registerOrchestrationTools(pi, {
-          runtime: host.runtime,
-          getCatalog: catalogFor,
-          getDispatchDecision: (toolCallId) =>
-            dispatchDecisions.get(toolCallId) ?? { mode: "inline" },
-        });
-        toolsRegistered = true;
-      }
+      registerOrchestrationTools(pi, {
+        runtime: host.runtime,
+        getCatalog: catalogFor,
+        getDispatchDecision: (toolCallId) =>
+          dispatchDecisions.get(toolCallId) ?? { mode: "inline" },
+      });
       hostAttachment ??= attachProcessHost(host);
 
       dispatchDecisions.clear();
@@ -132,6 +120,8 @@ export function createOrchestrationExtension(
       );
       const ownerSessionId = activeBinding?.ownerSessionId;
       if (!ownerSessionId) return;
+      // Sole dispatches and homogeneous orchestrate waves detach; mixed tools stay with the
+      // current parent turn, while a wave shares one boundary for one later synthesis turn.
       const isOrchestrateGroup =
         toolCalls.length > 1 &&
         toolCalls.every((toolCall) => toolCall.name === "orchestrate");

package/extension/presentation.ts

@@ -83,8 +83,6 @@ export class StatusController {
   private disposed = false;
   private unsubscribeState: (() => void) | undefined;
   private widget: WorkerStatusComponent | undefined;
-  private widgetInstalled = false;
-  private pendingSnapshot: RuntimeSnapshot | undefined;
 
   constructor(private readonly runtime: PresentationRuntime) {}
 
@@ -114,36 +112,35 @@ export class StatusController {
     ctx.ui.setStatus(ORCHESTRATION_PRESENTATION_KEY, formatFooterStatus(snapshot));
     if (ctx.mode !== "tui") return;
     const active = activeWorkers(snapshot);
-    this.pendingSnapshot = snapshot;
     if (active.length === 0) {
-      if (this.widgetInstalled) ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
-      this.widget = undefined;
-      this.widgetInstalled = false;
+      if (this.widget !== undefined) {
+        ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
+        this.widget = undefined;
+      }
       return;
     }
-    if (this.widget) {
+    if (this.widget !== undefined) {
       this.widget.update(snapshot);
       return;
     }
-    if (this.widgetInstalled) return;
     ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, (tui, theme) => {
-      this.widget = new WorkerStatusComponent(this.pendingSnapshot ?? snapshot, theme, tui);
-      return this.widget;
+      const widget = new WorkerStatusComponent(snapshot, theme, tui);
+      this.widget = widget;
+      return widget;
     }, { placement: "aboveEditor" });
-    this.widgetInstalled = true;
   }
 
   private clearBinding(): void {
     const unsubscribeState = this.unsubscribeState;
     this.unsubscribeState = undefined;
     unsubscribeState?.();
-    this.widget = undefined;
-    this.pendingSnapshot = undefined;
     const current = this.binding;
     if (!current) return;
     current.ctx.ui.setStatus(ORCHESTRATION_PRESENTATION_KEY, undefined);
-    if (current.ctx.mode === "tui" && this.widgetInstalled) current.ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
-    this.widgetInstalled = false;
+    if (current.ctx.mode === "tui" && this.widget !== undefined) {
+      current.ctx.ui.setWidget(ORCHESTRATION_PRESENTATION_KEY, undefined);
+      this.widget = undefined;
+    }
     this.binding = undefined;
   }
 }

package/extension/runtime.ts

@@ -205,6 +205,7 @@ interface RuntimeWorker {
   readonly record: WorkerRecord;
   readonly context: OrchestrationContext;
   readonly definition: WorkerDefinition;
+  // Worker-local authority fence; stale asynchronous callbacks must revalidate it.
   readonly generation: number;
   readonly session?: WorkerSessionHandle;
   readonly observationRelease?: () => void;
@@ -271,9 +272,6 @@ class StatefulOrchestration implements OrchestrationService {
       effect: Effect.Effect<void, never>,
     ) => Fiber.Fiber<void, never>,
     private readonly cleanups: FiberSet.FiberSet<void, never>,
-    private readonly runCleanup: (
-      effect: Effect.Effect<void, never>,
-    ) => Fiber.Fiber<void, never>,
     private readonly clock: Clock.Clock,
     private readonly idFactories: OrchestrateIdFactories,
     private readonly shutdownCompletion: Deferred.Deferred<void>,
@@ -429,34 +427,16 @@ class StatefulOrchestration implements OrchestrationService {
       };
 
       const admission = this.transact((draft) => {
-        const open = openDecision(draft, "sendInteractive");
-        if (open._tag === "rejected") return { value: open };
-        const ownership = ownedWorkerDecision(
+        const ready = readyInteractiveDecision(
           draft,
-          "sendInteractive",
           context.ownerSessionId,
           validatedWorkerId,
         );
-        if (ownership._tag === "rejected") return { value: ownership };
-
-        const worker = ownership.value;
-        if (
-          worker.record.lifecycle !== "interactive" ||
-          worker.record.status !== "ready" ||
-          !worker.session
-        ) {
-          return {
-            value: rejected(
-              "sendInteractive",
-              "worker-state",
-              "interactive_send requires an owned ready interactive worker",
-            ),
-          };
-        }
+        if (ready._tag === "rejected") return { value: ready };
         if (draft.runs.has(runId)) throw new Error(`Duplicate run ID: ${runId}`);
 
+        const { worker, session } = ready.value;
         const generation = worker.generation + 1;
-        const session = worker.session;
         const runningRecord: WorkerRecord = {
           ...transitionWorkerStatus(worker.record, "running"),
           runId,
@@ -822,6 +802,7 @@ class StatefulOrchestration implements OrchestrationService {
         ),
       );
       const exit = fiber.pollUnsafe();
+      // A closed FiberMap rejects admission with an interrupted sentinel.
       if (exit && Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
         this.settleGenerationLaunchFailure(workerId, generation);
       }
@@ -1261,6 +1242,8 @@ class StatefulOrchestration implements OrchestrationService {
     });
   }
 
+  // Commit stopping and one shared completion before post-commit physical abort
+  // and generation interruption; every cancellation caller joins it.
   private markWorkersStopping(
     draft: RuntimeState,
     workers: readonly RuntimeWorker[],
@@ -1305,6 +1288,7 @@ class StatefulOrchestration implements OrchestrationService {
   ): void {
     const fiber = this.runCancellation(this.cancelWorker(workerId, completion));
     const exit = fiber.pollUnsafe();
+    // A closed FiberSet rejects admission with an interrupted sentinel.
     if (!exit || Exit.isSuccess(exit) || !Cause.hasInterruptsOnly(exit.cause)) return;
 
     const worker = this.current().workers.get(workerId);
@@ -1461,7 +1445,7 @@ class StatefulOrchestration implements OrchestrationService {
     const session = worker.session;
     if (session) {
       actions.push(runAction(() => {
-        this.launchCleanupOrJoinAfterClosure(
+        this.launchCleanup(
           Effect.suspend(() => session.dispose()).pipe(
             Effect.catchCause(() => Effect.void),
             Effect.uninterruptible,
@@ -1472,19 +1456,9 @@ class StatefulOrchestration implements OrchestrationService {
     return actions;
   }
 
-  private launchCleanupOrJoinAfterClosure(cleanup: Effect.Effect<void>): void {
-    if (this.cleanups.state._tag === "Closed") {
-      Effect.runFork(cleanup);
-      return;
-    }
-    const fiber = this.runCleanup(cleanup);
-    const exit = fiber.pollUnsafe();
-    if (exit && Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
-      // FiberSet.runtime returns an already-interrupted sentinel when closure
-      // wins admission. If admission won and closure interrupted the real fiber,
-      // repeating the cached uninterruptible disposal only joins that cleanup.
-      Effect.runFork(cleanup);
-    }
+  private launchCleanup(cleanup: Effect.Effect<void>): void {
+    const fiber = Effect.runFork(cleanup);
+    FiberSet.addUnsafe(this.cleanups, fiber);
   }
 
   private preflightOpen(
@@ -1500,30 +1474,12 @@ class StatefulOrchestration implements OrchestrationService {
     workerId: WorkerId,
   ): Decision<void> {
     return this.transact((draft) => {
-      const open = openDecision(draft, "sendInteractive");
-      if (open._tag === "rejected") return { value: open };
-      const ownership = ownedWorkerDecision(
-        draft,
-        "sendInteractive",
-        ownerSessionId,
-        workerId,
-      );
-      if (ownership._tag === "rejected") return { value: ownership };
-      const worker = ownership.value;
-      if (
-        worker.record.lifecycle !== "interactive" ||
-        worker.record.status !== "ready" ||
-        !worker.session
-      ) {
-        return {
-          value: rejected(
-            "sendInteractive",
-            "worker-state",
-            "interactive_send requires an owned ready interactive worker",
-          ),
-        };
-      }
-      return { value: accepted(undefined) };
+      const ready = readyInteractiveDecision(draft, ownerSessionId, workerId);
+      return {
+        value: ready._tag === "accepted"
+          ? accepted(undefined)
+          : ready,
+      };
     });
   }
 
@@ -1536,6 +1492,7 @@ class StatefulOrchestration implements OrchestrationService {
   ): A {
     const draft = makeDraft(this.state);
     const mutation = reducer(draft);
+    // Commit before action factories capture the snapshot and callbacks can run.
     this.state = Object.freeze(draft);
     this.enqueueActions((mutation.actions ?? []).map((action) => action(
       this.state,
@@ -1546,6 +1503,7 @@ class StatefulOrchestration implements OrchestrationService {
   }
 
   private enqueueActions(actions: readonly CommittedAction[]): void {
+    // Reentrant actions queue behind this drain; drain all before rethrowing the first failure.
     this.actionQueue.push(...actions);
     if (this.drainingActions) return;
 
@@ -1580,7 +1538,6 @@ export function orchestrationLayer(
       // Scope finalizers run in reverse acquisition order. Keep cleanup open while
       // generation and cancellation interruption settle workers and enqueue disposal.
       const cleanups = yield* FiberSet.make<void, never>();
-      const runCleanup = yield* FiberSet.runtime(cleanups)<never>();
       const cancellations = yield* FiberSet.make<void, never>();
       const runCancellation = yield* FiberSet.runtime(cancellations)<never>();
       const generations = yield* FiberMap.make<WorkerId, void, never>();
@@ -1594,7 +1551,6 @@ export function orchestrationLayer(
         cancellations,
         runCancellation,
         cleanups,
-        runCleanup,
         clock,
         options.idFactories ?? createRandomIdFactories(),
         shutdownCompletion,
@@ -1875,6 +1831,38 @@ function ownedWorkerDecision(
     : accepted(worker);
 }
 
+function readyInteractiveDecision(
+  draft: RuntimeState,
+  ownerSessionId: string,
+  workerId: WorkerId,
+): Decision<{
+  readonly worker: RuntimeWorker;
+  readonly session: WorkerSessionHandle;
+}> {
+  const open = openDecision(draft, "sendInteractive");
+  if (open._tag === "rejected") return open;
+  const ownership = ownedWorkerDecision(
+    draft,
+    "sendInteractive",
+    ownerSessionId,
+    workerId,
+  );
+  if (ownership._tag === "rejected") return ownership;
+  const worker = ownership.value;
+  if (
+    worker.record.lifecycle !== "interactive" ||
+    worker.record.status !== "ready" ||
+    !worker.session
+  ) {
+    return rejected(
+      "sendInteractive",
+      "worker-state",
+      "interactive_send requires an owned ready interactive worker",
+    );
+  }
+  return accepted({ worker, session: worker.session });
+}
+
 function accepted<A>(value: A): Decision<A> {
   return { _tag: "accepted", value };
 }

package/extension/tools.ts

@@ -162,7 +162,14 @@ export function registerOrchestrationTools(
       return renderDispatchCall(theme, args, expanded);
     },
     renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderOrchestrationResult(result, isPartial, expanded, theme, context.lastComponent);
+      return renderOrchestrationResult(
+        result,
+        isPartial,
+        expanded,
+        theme,
+        context.isError,
+        context.lastComponent,
+      );
     },
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       const decision = deps.getDispatchDecision(toolCallId);
@@ -210,8 +217,8 @@ export function registerOrchestrationTools(
     renderCall(_args, theme) {
       return new Text(theme.fg("toolTitle", theme.bold("worker_status")), 0, 0);
     },
-    renderResult(result, { isPartial }, theme) {
-      return renderDiagnosticsResult(result, isPartial, theme);
+    renderResult(result, { isPartial }, theme, context) {
+      return renderDiagnosticsResult(result, isPartial, context.isError, theme);
     },
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const ownerSessionId = ctx.sessionManager.getSessionId();
@@ -236,10 +243,24 @@ export function registerOrchestrationTools(
     ],
     parameters: interactiveSendSchema,
     renderCall(args, theme, { expanded }) {
-      return renderInteractiveMessageCall(theme, "interactive_send", args.worker_id, args.instructions, expanded);
+      const fields = recordFields(args);
+      return renderInteractiveMessageCall(
+        theme,
+        "interactive_send",
+        fields.worker_id,
+        fields.instructions,
+        expanded,
+      );
     },
     renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderOrchestrationResult(result, isPartial, expanded, theme, context.lastComponent);
+      return renderOrchestrationResult(
+        result,
+        isPartial,
+        expanded,
+        theme,
+        context.isError,
+        context.lastComponent,
+      );
     },
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       const workerId = params.worker_id;
@@ -287,13 +308,23 @@ export function registerOrchestrationTools(
     ],
     parameters: workerAbortSchema,
     renderCall(args, theme) {
-      const target = "worker_ids" in args
-        ? `${args.worker_ids.length} worker${args.worker_ids.length === 1 ? "" : "s"}`
-        : "all workers";
+      const fields = recordFields(args);
+      const workerIds = Array.isArray(fields.worker_ids)
+        ? fields.worker_ids
+        : undefined;
+      const target = workerIds
+        ? `${workerIds.length} worker${workerIds.length === 1 ? "" : "s"}`
+        : fields.all === true ? "all workers" : "";
       return renderCompactCall(theme, "worker_abort", target);
     },
-    renderResult(result, { isPartial }, theme) {
-      return renderSimpleResult(result, isPartial ? "Requesting worker stop…" : "Worker stop requested", theme, "warning");
+    renderResult(result, { isPartial }, theme, context) {
+      return renderSimpleResult(
+        result,
+        context.isError,
+        isPartial ? "Requesting worker stop…" : "Worker stop requested",
+        theme,
+        "warning",
+      );
     },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const ownerSessionId = ctx.sessionManager.getSessionId();
@@ -318,10 +349,16 @@ export function registerOrchestrationTools(
     ],
     parameters: interactiveCloseSchema,
     renderCall(args, theme) {
-      return renderCompactCall(theme, "interactive_close", args.worker_id);
+      const fields = recordFields(args);
+      return renderCompactCall(theme, "interactive_close", fields.worker_id);
     },
-    renderResult(result, { isPartial }, theme) {
-      return renderSimpleResult(result, isPartial ? "Closing worker…" : "✓ Worker closed", theme);
+    renderResult(result, { isPartial }, theme, context) {
+      return renderSimpleResult(
+        result,
+        context.isError,
+        isPartial ? "Closing worker…" : "✓ Worker closed",
+        theme,
+      );
     },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const ownerSessionId = ctx.sessionManager.getSessionId();
@@ -531,31 +568,26 @@ function readableDetails(title: string, details: unknown): string {
   return `${truncation.content}\n\n[Output truncated: ${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}. Full structured details remain available.]`;
 }
 
-interface RenderableTask {
-  readonly worker?: unknown;
-  readonly title?: unknown;
-  readonly instructions?: unknown;
-}
-
 function renderDispatchCall(
   theme: Theme,
-  task: RenderableTask,
+  task: unknown,
   expanded: boolean,
 ): Component {
+  const fields = isRecord(task) ? task : {};
   const container = new Container();
   container.addChild(new Text(
-    theme.fg("toolTitle", theme.bold("orchestrate ")) + theme.fg("muted", safeTerminalText(task.worker)),
+    theme.fg("toolTitle", theme.bold("orchestrate ")) + theme.fg("muted", safeTerminalText(fields.worker)),
     0, 0,
   ));
   container.addChild(new Text(
-    `${theme.fg("accent", "→")} ${theme.fg("text", theme.bold(safeTerminalText(task.title)))}`,
+    `${theme.fg("accent", "→")} ${theme.fg("text", theme.bold(safeTerminalText(fields.title)))}`,
     0, 0,
   ));
   if (expanded) {
-    container.addChild(new Text(safeTerminalText(task.instructions), 2, 0));
+    container.addChild(new Text(safeTerminalText(fields.instructions), 2, 0));
     return new WidthBoundComponent(container);
   }
-  container.addChild(new InstructionPreview(task.instructions, theme));
+  container.addChild(new InstructionPreview(fields.instructions, theme));
   container.addChild(new Text(theme.fg("dim", keyHint("app.tools.expand", "to inspect full instructions")), 0, 0));
   return new WidthBoundComponent(container);
 }
@@ -642,8 +674,18 @@ function renderOrchestrationResult(
   isPartial: boolean,
   expanded: boolean,
   theme: Theme,
+  isError: boolean,
   lastComponent: unknown,
 ): Component {
+  if (isError) {
+    return new WidthBoundComponent(renderSimpleResult(
+      result,
+      true,
+      firstResultLine(result) || "Worker operation failed",
+      theme,
+      "warning",
+    ));
+  }
   const details = result.details;
   if (Result.isSuccess(decodeAcceptedRunRenderDetails(details))) {
     return new WidthBoundComponent(new Text(theme.fg("success", "Sent to worker") + theme.fg("dim", " · response arrives when complete"), 0, 0));
@@ -660,7 +702,13 @@ function renderOrchestrationResult(
     return new WidthBoundComponent(new Text(theme.fg("warning", "Worker result details unavailable"), 0, 0));
   }
   if (isPartial) return new WidthBoundComponent(new Text(theme.fg("warning", "Sending work…"), 0, 0));
-  return new WidthBoundComponent(renderSimpleResult(result, firstResultLine(result) || "Work sent", theme, "warning"));
+  return new WidthBoundComponent(renderSimpleResult(
+    result,
+    false,
+    firstResultLine(result) || "Work sent",
+    theme,
+    "warning",
+  ));
 }
 
 interface RenderedInlineSettlement {
@@ -736,7 +784,20 @@ function readInlineResult(details: unknown): RenderedInlineSettlement | undefine
   };
 }
 
-function renderDiagnosticsResult(result: AgentToolResult<unknown>, isPartial: boolean, theme: Theme): Text {
+function renderDiagnosticsResult(
+  result: AgentToolResult<unknown>,
+  isPartial: boolean,
+  isError: boolean,
+  theme: Theme,
+): Text {
+  if (isError) {
+    return renderSimpleResult(
+      result,
+      true,
+      firstResultLine(result) || "Worker diagnostics failed",
+      theme,
+    );
+  }
   if (isPartial) return new Text(theme.fg("muted", "Reading worker diagnostics…"), 0, 0);
   const details = result.details;
   if (isRecord(details) && isRecord(details.state) && Array.isArray(details.state.workers)) {
@@ -752,12 +813,13 @@ function renderDiagnosticsResult(result: AgentToolResult<unknown>, isPartial: bo
 
 function renderSimpleResult(
   result: AgentToolResult<unknown>,
+  isError: boolean,
   message: string,
   theme: Theme,
   normalColor: "success" | "warning" = "success",
 ): Text {
-  const failed = "isError" in result && result.isError === true;
-  return new Text(theme.fg(failed ? "error" : normalColor, failed ? firstResultLine(result) || message : message), 0, 0);
+  const text = isError ? firstResultLine(result) || message : message;
+  return new Text(theme.fg(isError ? "error" : normalColor, text), 0, 0);
 }
 
 function firstResultLine(result: AgentToolResult<unknown>): string | undefined {
@@ -766,6 +828,10 @@ function firstResultLine(result: AgentToolResult<unknown>): string | undefined {
   return first.text.split("\n").find((line) => line.trim())?.trim();
 }
 
+function recordFields(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }

package/package.json

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