@zachwill/pi-orchestrate 0.15.0 → 0.16.0

package/README.md

@@ -1,6 +1,6 @@
 # Pi Orchestrate
 
-[`@zachwill/pi-orchestrate`](https://www.npmjs.com/package/@zachwill/pi-orchestrate) lets a Pi session delegate work to direct child sessions.
+[`@zachwill/pi-orchestrate`](https://www.npmjs.com/package/@zachwill/pi-orchestrate) lets a Pi session delegate work to direct child sessions. It requires Pi 0.85.0 or newer.
 
 - Each worker gets a focused brief and a separate conversation.
 - Workers run independently and return their results to the parent.
@@ -23,6 +23,14 @@ A **worker ID** identifies a worker session. A **run ID** identifies one generat
 
 Interactive workers remain available across session switches and extension reloads within the same Pi process. Closing one releases its retained session; process shutdown releases any that remain.
 
+## Compaction
+
+Parent compaction does not stop workers. Results that settle during compaction remain queued for the owning session and resume automatic delivery when that session becomes idle, including after failed or cancelled compaction. Grouped work still triggers synthesis only after the group settles.
+
+Before each parent model request, the extension adds a fresh, owner-scoped snapshot of active workers and ready interactive sessions. This transient context survives compaction by being rebuilt from live state; it is not appended to the transcript. The snapshot is capped at 12 KiB and reports omitted workers or truncated assignments, with `worker_status` available for recovery rather than polling.
+
+This state belongs to the running Pi process. Compaction does not require restarting workers, and persisted transcripts do not restore running workers after a process restart.
+
 ## Agent interface
 
 Pi Orchestrate gives the parent five model-facing tools:

package/examples/workers/investigator.md

@@ -1,15 +1,13 @@
 ---
 name: investigator
-description: Investigates cross-file questions and synthesizes grounded evidence.
+description: Investigates cross-file questions through read-only inspection and evidence-based synthesis.
 thinking: medium
 tools: read, grep, find, ls, bash
 lifecycle: one-shot
 ---
 
-Investigate the assigned cross-file question through read-only inspection, comparison, and evidence synthesis.
+Investigate the assigned question, tracing relevant relationships and comparing evidence across files. Stay within scope and stop when the evidence supports an answer; do not keep exploring for completeness.
 
-Do not modify files or run builds, tests, or commands that mutate state. Use bash only for read-only commands.
+Do not modify files or run builds, tests, or other state-changing commands. Use bash only for read-only inspection.
 
-Ground each finding in file paths, line ranges, or symbols. Distinguish confirmed behavior from inference, connect evidence across files, and explain the resulting system shape or conclusion. Provide grounded recommendations when the assignment requests them.
-
-Return concise **Findings** and **Synthesis** sections. Add **Gaps** only for material unresolved questions and **Start Here** only when useful.
+Lead with the answer. Support material findings and requested recommendations with exact paths, line ranges, or symbols. Explain how the evidence supports the conclusion, distinguish facts from inference, and identify unresolved gaps that could change the answer.

package/examples/workers/scout.md

@@ -1,15 +1,13 @@
 ---
 name: scout
-description: Answers one small factual repository question with read-only evidence.
-thinking: medium
+description: Answers a small factual repository question through shallow, read-only inspection.
+thinking: low
 tools: read, grep, find, ls, bash
 lifecycle: one-shot
 ---
 
-Answer one small factual probe through fast, shallow, read-only repository inspection.
+Answer the assigned factual question using direct repository evidence. Keep the inspection shallow and stop as soon as the question is answerable. If it requires deeper investigation, return what you found and explain what remains rather than expanding the task.
 
-Do not modify files or run builds, tests, or commands that mutate state. Use bash only for read-only commands.
+Do not modify files or run builds, tests, or other state-changing commands. Use bash only for read-only inspection.
 
-Accept one path, symbol, command output, short inventory, direct comparison, or existence check. If the assignment requires broader investigation, synthesis, architecture judgment, planning, or implementation, stop concisely and recommend the investigator.
-
-Return a short **Answer** and **Evidence** grounded in paths, line ranges, symbols, or command output. Add **Gaps** only when material.
+Lead with a short answer and cite the paths, line ranges, symbols, or command output needed to support it. Distinguish confirmed facts from inference and identify missing evidence that affects the answer.

package/examples/workers/web.md

@@ -8,19 +8,13 @@ skills: []
 lifecycle: one-shot
 ---
 
-You are a web research worker. Understand the assigned research objective, choose an efficient search strategy, and return a useful source-grounded synthesis in the assignment's language.
+Answer the assigned question using public web sources.
 
 Use the installed, authenticated `codex` CLI as your web-search backend. This external search process is explicitly part of your task; do not invoke Pi or other Pi workers. Do not modify project files or install anything. Use fresh temporary directories and clean them up.
 
 ## Strategy
 
-Use your judgment:
-
-- For a narrow lookup, run one focused Codex search.
-- For independent entities, claims, or source families, run separate focused searches in parallel by issuing sibling bash calls in the same turn.
-- For dependent questions, search serially so later work can use earlier evidence.
-- Use a follow-up search only for a material gap, conflict, or verification need.
-- Stop when the objective is adequately answered. Do not multiply searches for cosmetic coverage.
+Use one focused search for a narrow lookup. Search independent angles in parallel and dependent questions serially. Follow up only to resolve a material gap, conflict, or verification need. Stop when the question is adequately answered.
 
 Tell each Codex process to use at most four actual web searches unless the assignment justifies a different bound. Use cached search for stable documentation or background and live search for current or time-sensitive questions.
 
@@ -74,11 +68,6 @@ Never use `--dangerously-bypass-approvals-and-sandbox`. Retry only when diagnost
 
 ## Response
 
-Return a concise synthesis that directly serves the assignment. Include:
-
-- the answer or strongest supported conclusion;
-- material findings and conflicts;
-- source titles with exact URLs and relevance;
-- unresolved gaps or cautions when they matter.
+Lead with the strongest supported answer. Cite exact source URLs alongside material factual claims. Identify conflicts, uncertainty, and freshness limits that affect the conclusion.
 
 Do not dump search transcripts or raw temporary paths. If research fails, say what failed and return any useful partial evidence.

package/examples/workers/worker.md

@@ -1,18 +1,17 @@
 ---
 name: worker
-description: Implements a bounded change within explicit scope and acceptance criteria.
+description: Implements bounded code changes, fixes, and refactors.
 thinking: medium
 tools: read, bash, edit, write, grep, find, ls
 lifecycle: one-shot
 ---
 
-Implement the assigned change within its stated scope.
+Complete the assigned change within its scope. Follow project instructions, inspect nearby code, and preserve changes you do not own. Report relevant out-of-scope findings rather than fixing them.
 
-- Follow loaded project conventions. Inspect nearby code and reuse existing helpers and patterns before writing new code.
-- Change only what the assignment requires. Do not fix, refactor, or investigate unrelated work.
-- Do not commit, push, or perform destructive actions unless assigned.
-- Stop and report a blocker rather than guessing when a required decision is unclear.
-- Remove unused imports, dead code, debug output, and other leftovers from your changes.
-- Run only the narrowest relevant verification permitted by the assignment and project conventions. Report pre-existing failures separately; fix only failures caused by your changes.
+Resolve uncertainty through inspection where possible. Make reasonable, reversible decisions within the assignment; report a blocker when progress requires missing authority or a material decision the assignment does not resolve.
 
-Return concise sections for **Completed**, **Files Changed**, and **Verification**. Add **Blockers** only when blocked and **Observations** only for directly relevant out-of-scope findings.
+Run checks that establish whether the change works, following the assignment and project requirements. Fix failures introduced by your work and remove leftovers from your changes. Report pre-existing failures separately.
+
+Lead with the result. Include changed paths, verification performed, and anything unresolved. Use the structure the handoff needs rather than a fixed template.
+
+Do not commit, push, deploy, or take destructive action unless explicitly authorized.

package/extension/index.ts

@@ -9,6 +9,10 @@ import {
 } from "./catalog/discovery.ts";
 import type { WorkerCatalog } from "./catalog/definition.ts";
 import { applyOrchestratorContract } from "./parent/contract.ts";
+import {
+  projectLiveWorkerContext,
+  replaceLiveWorkerContext,
+} from "./parent/worker-context.ts";
 import {
   attachProcessHost,
   createProcessHost,
@@ -110,6 +114,52 @@ export function createOrchestrationExtension(
       };
     });
 
+    pi.on("context", async (event, ctx) => {
+      const messages = replaceLiveWorkerContext(event.messages, undefined);
+      const binding = activeBinding;
+      const boundHost = host;
+      const attachment = hostAttachment;
+
+      if (!binding || !boundHost || !attachment) return { messages };
+
+      try {
+        if (
+          attachment.host !== boundHost ||
+          ctx.sessionManager.getSessionId() !== binding.ownerSessionId
+        ) {
+          return { messages };
+        }
+
+        const snapshot = await boundHost.orchestration.snapshot(
+          binding.ownerSessionId,
+        );
+
+        // Session replacement and reload can race the awaited snapshot. Only the
+        // exact attachment generation that requested it may add parent context.
+        if (
+          activeBinding !== binding ||
+          host !== boundHost ||
+          hostAttachment !== attachment ||
+          attachment.host !== boundHost ||
+          ctx.sessionManager.getSessionId() !== binding.ownerSessionId
+        ) {
+          return { messages };
+        }
+
+        const context = projectLiveWorkerContext(snapshot, {
+          ownerSessionId: binding.ownerSessionId,
+          pendingResultCount: boundHost.delivery.pendingCount(
+            binding.ownerSessionId,
+          ),
+        });
+        return { messages: replaceLiveWorkerContext(messages, context) };
+      } catch {
+        // A context projection is advisory. On snapshot or stale-context failure,
+        // omit it rather than retaining an older authority-bearing projection.
+        return { messages };
+      }
+    });
+
     pi.on("message_end", (event) => {
       if (event.message.role !== "assistant") return;
       const toolCalls = event.message.content.filter(

package/extension/parent/contract.ts

@@ -125,6 +125,7 @@ You are responsible for delivering the user’s requested outcome. Work directly
 ### Completion
 
 - After dispatching, wait for automatic result delivery instead of polling \`worker_status\`. Do not call \`sleep\`, poll with another tool, inspect progress indirectly, or issue no-op calls.
+- Compaction does not stop workers. A fresh live-worker context snapshot identifies active assignments and ready interactive sessions; use it rather than stale status in conversation summaries. Do not redispatch work because its dispatch was compacted away. If the snapshot is truncated or state appears inconsistent, use \`worker_status\` once for recovery, not polling.
 - While waiting, perform only already-admitted independent work from the current change; otherwise end the turn.
 - Classify findings before acting: fix or remove defects introduced by the current change, complete unfinished requirements inside its boundary, and record adjacent or pre-existing concerns without admitting them.
 - Dispatch another wave only for admitted work inside the current change. Independence, local correctness, reviewer concern, or consistency alone does not justify more work.

package/extension/parent/delivery.ts

@@ -10,6 +10,7 @@ export const DELIVERY_PARENT_INSTRUCTIONS =
   "Parent: Synthesize all results, resolve conflicts, review changes and evidence, run integration checks, and continue the user's task. Do not merely forward worker reports.";
 
 export type ParentBindingGeneration = string | number | symbol;
+export type ScheduleIdleRecheck = (recheck: () => void) => () => void;
 
 export interface WorkerDeliveryMessage {
   readonly customType: "pi-orchestrate-worker-result";
@@ -34,6 +35,11 @@ interface BoundParent {
   agentRunning: boolean;
 }
 
+interface ScheduledIdleRecheck {
+  readonly generation: ParentBindingGeneration;
+  cancel(): void;
+}
+
 interface SynthesisGroupState {
   expected: number;
   readonly acceptedEventIds: string[];
@@ -63,21 +69,30 @@ export class DeliveryCoordinator implements DeliveryService {
   private readonly boundParents = new Map<string, BoundParent>();
   private readonly pendingSettlements: WorkerSettlement[] = [];
   private readonly flushingOwners = new Set<string>();
+  private readonly idleRechecks = new Map<string, ScheduledIdleRecheck>();
   private readonly synthesisGroups = new Map<string, SynthesisGroupState>();
   // Orchestration settlement sequences are process-scoped and monotonic across
   // owners, so one watermark is valid.
   private highestAcceptedSequence = 0;
 
+  constructor(
+    private readonly scheduleIdleRecheck: ScheduleIdleRecheck = scheduleDeliveryIdleRecheck,
+  ) {}
+
   bind(binding: ParentBinding): void {
+    this.cancelIdleRecheck(binding.ownerSessionId);
     this.boundParents.set(binding.ownerSessionId, {
       binding,
-      agentRunning: !binding.isIdle(),
+      // Non-idle also covers manual compaction. Agent lifecycle events, rather
+      // than the broader idle flag, own this state.
+      agentRunning: false,
     });
     this.flush(binding.ownerSessionId, binding.generation);
   }
 
   unbind(ownerSessionId: string, generation: ParentBindingGeneration): void {
     if (!this.matchesBinding(ownerSessionId, generation)) return;
+    this.cancelIdleRecheck(ownerSessionId, generation);
     this.boundParents.delete(ownerSessionId);
   }
 
@@ -85,6 +100,7 @@ export class DeliveryCoordinator implements DeliveryService {
     const parent = this.boundParents.get(ownerSessionId);
     if (parent?.binding.generation !== generation) return;
     parent.agentRunning = true;
+    this.cancelIdleRecheck(ownerSessionId, generation);
   }
 
   markAgentSettled(ownerSessionId: string, generation: ParentBindingGeneration): void {
@@ -130,6 +146,8 @@ export class DeliveryCoordinator implements DeliveryService {
   }
 
   clear(): void {
+    for (const recheck of this.idleRechecks.values()) recheck.cancel();
+    this.idleRechecks.clear();
     this.boundParents.clear();
     this.pendingSettlements.length = 0;
     this.flushingOwners.clear();
@@ -146,18 +164,28 @@ export class DeliveryCoordinator implements DeliveryService {
 
   private canDeliver(ownerSessionId: string, generation: ParentBindingGeneration): boolean {
     const parent = this.boundParents.get(ownerSessionId);
-    return (
-      parent !== undefined &&
-      parent.binding.generation === generation &&
-      !parent.agentRunning &&
-      parent.binding.isIdle()
-    );
+    if (
+      parent === undefined ||
+      parent.binding.generation !== generation ||
+      parent.agentRunning
+    ) {
+      return false;
+    }
+    if (!parent.binding.isIdle()) {
+      this.ensureIdleRecheck(ownerSessionId, generation);
+      return false;
+    }
+    this.cancelIdleRecheck(ownerSessionId, generation);
+    return true;
   }
 
   private flush(ownerSessionId: string, generation: ParentBindingGeneration): void {
-    if (this.flushingOwners.has(ownerSessionId) || !this.canDeliver(ownerSessionId, generation)) {
+    if (this.flushingOwners.has(ownerSessionId)) return;
+    if (this.pendingCount(ownerSessionId) === 0) {
+      this.cancelIdleRecheck(ownerSessionId, generation);
       return;
     }
+    if (!this.canDeliver(ownerSessionId, generation)) return;
 
     this.flushingOwners.add(ownerSessionId);
     try {
@@ -216,6 +244,36 @@ export class DeliveryCoordinator implements DeliveryService {
     }
   }
 
+  private ensureIdleRecheck(
+    ownerSessionId: string,
+    generation: ParentBindingGeneration,
+  ): void {
+    const current = this.idleRechecks.get(ownerSessionId);
+    if (current?.generation === generation) return;
+    current?.cancel();
+
+    const scheduled: ScheduledIdleRecheck = {
+      generation,
+      cancel: () => {},
+    };
+    this.idleRechecks.set(ownerSessionId, scheduled);
+    scheduled.cancel = this.scheduleIdleRecheck(() => {
+      if (this.idleRechecks.get(ownerSessionId) !== scheduled) return;
+      this.idleRechecks.delete(ownerSessionId);
+      this.flush(ownerSessionId, generation);
+    });
+  }
+
+  private cancelIdleRecheck(
+    ownerSessionId: string,
+    generation?: ParentBindingGeneration,
+  ): void {
+    const scheduled = this.idleRechecks.get(ownerSessionId);
+    if (!scheduled || (generation !== undefined && scheduled.generation !== generation)) return;
+    this.idleRechecks.delete(ownerSessionId);
+    scheduled.cancel();
+  }
+
   private renderWorkerMessage(
     settlement: WorkerSettlement,
     byteLimit: number,
@@ -302,6 +360,12 @@ export const deliveryLayer: Layer.Layer<Delivery, never, Orchestration> = Layer.
   }),
 );
 
+function scheduleDeliveryIdleRecheck(recheck: () => void): () => void {
+  const timeout = setTimeout(recheck, 100);
+  timeout.unref();
+  return () => clearTimeout(timeout);
+}
+
 function synthesisGroupKey(ownerSessionId: string, synthesisGroupId: string): string {
   return `${ownerSessionId}\u0000${synthesisGroupId}`;
 }

package/extension/parent/worker-context.ts

@@ -0,0 +1,196 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type {} from "@earendil-works/pi-coding-agent";
+import type { WorkerRecord } from "../orchestration/model.ts";
+import type { OwnerSnapshot } from "../orchestration/service.ts";
+
+export const LIVE_WORKER_CONTEXT_TYPE = "pi-orchestrate-live-worker-context";
+export const MAX_LIVE_WORKER_CONTEXT_BYTES = 12 * 1024;
+export const MAX_LIVE_WORKER_ITEM_BYTES = 1024;
+export const MAX_LIVE_WORKER_ASSIGNMENT_BYTES = 480;
+
+const ACTIVE_STATUSES = new Set<WorkerRecord["status"]>([
+  "starting",
+  "running",
+  "stopping",
+]);
+const ITEM_TRUNCATION_MARKER =
+  "\n  [entry truncated; use worker_status once for diagnostics/recovery]";
+const ASSIGNMENT_TRUNCATION_MARKER = " … [assignment excerpt truncated]";
+
+type CustomMessage = Extract<AgentMessage, { readonly role: "custom" }>;
+
+export interface LiveWorkerContextOptions {
+  readonly ownerSessionId: string;
+  readonly pendingResultCount: number;
+  readonly timestamp?: number;
+}
+
+/** Project only current actionable process state; terminal history and outcomes stay out. */
+export function projectLiveWorkerContext(
+  snapshot: OwnerSnapshot,
+  options: LiveWorkerContextOptions,
+): CustomMessage | undefined {
+  const workers = snapshot.workers.filter((worker) =>
+    worker.ownerSessionId === options.ownerSessionId && isActionable(worker)
+  );
+  const pendingResultCount = normalizeCount(options.pendingResultCount);
+  if (workers.length === 0 && pendingResultCount === 0) return undefined;
+
+  const activeCount = workers.filter((worker) => ACTIVE_STATUSES.has(worker.status)).length;
+  const readyCount = workers.length - activeCount;
+  const items = workers.map(renderWorkerItem);
+  const content = renderBoundedContext(
+    items,
+    activeCount,
+    readyCount,
+    pendingResultCount,
+  );
+
+  return {
+    role: "custom",
+    customType: LIVE_WORKER_CONTEXT_TYPE,
+    content,
+    display: false,
+    timestamp: options.timestamp ?? Date.now(),
+  };
+}
+
+/** Replace this extension's transient projection while preserving every unrelated message. */
+export function replaceLiveWorkerContext(
+  messages: readonly AgentMessage[],
+  context: CustomMessage | undefined,
+): AgentMessage[] {
+  const retained = messages.filter((message) =>
+    message.role !== "custom" || message.customType !== LIVE_WORKER_CONTEXT_TYPE
+  );
+  return context ? [...retained, context] : retained;
+}
+
+function isActionable(worker: WorkerRecord): boolean {
+  return ACTIVE_STATUSES.has(worker.status) ||
+    (worker.status === "ready" && worker.lifecycle === "interactive");
+}
+
+function renderWorkerItem(worker: WorkerRecord): string {
+  const metadata = [
+    `worker_id=${quote(worker.id)}`,
+    `run_id=${quote(worker.runId)}`,
+    `definition=${quote(normalizeText(worker.worker))}`,
+    `title=${quote(normalizeText(worker.title))}`,
+    `lifecycle=${worker.lifecycle}`,
+    `status=${worker.status}`,
+  ].join(" | ");
+  const assignment = capUtf8(
+    normalizeText(worker.instructions),
+    MAX_LIVE_WORKER_ASSIGNMENT_BYTES,
+    ASSIGNMENT_TRUNCATION_MARKER,
+  );
+  const item = `- ${metadata}\n  assignment=${quote(assignment)}`;
+  return capUtf8(item, MAX_LIVE_WORKER_ITEM_BYTES, ITEM_TRUNCATION_MARKER);
+}
+
+function renderBoundedContext(
+  items: readonly string[],
+  activeCount: number,
+  readyCount: number,
+  pendingResultCount: number,
+): string {
+  for (let shown = items.length; shown >= 0; shown -= 1) {
+    const content = renderContext(
+      items.slice(0, shown),
+      items.length,
+      activeCount,
+      readyCount,
+      pendingResultCount,
+    );
+    if (utf8Bytes(content) <= MAX_LIVE_WORKER_CONTEXT_BYTES) return content;
+  }
+
+  // Fixed guidance is intentionally far below the global limit. Keep a defensive
+  // cap so future copy changes cannot violate the public bound.
+  return capUtf8(
+    renderContext([], items.length, activeCount, readyCount, pendingResultCount),
+    MAX_LIVE_WORKER_CONTEXT_BYTES,
+    "\n[Live worker context truncated; use worker_status once for recovery.]",
+  );
+}
+
+function renderContext(
+  shownItems: readonly string[],
+  totalWorkers: number,
+  activeCount: number,
+  readyCount: number,
+  pendingResultCount: number,
+): string {
+  const sections = [
+    "## Pi Orchestrate live worker context",
+    "Authoritative transient process snapshot for this parent provider call; it is not conversation history.",
+    `Relevant owned workers: ${totalWorkers} (${activeCount} active, ${readyCount} ready interactive).`,
+  ];
+
+  if (shownItems.length > 0) {
+    sections.push(shownItems.join("\n"));
+  }
+  if (shownItems.length < totalWorkers) {
+    const omitted = totalWorkers - shownItems.length;
+    sections.push(
+      `Snapshot overflow: showing ${shownItems.length} of ${totalWorkers}; ${omitted} worker${omitted === 1 ? "" : "s"} omitted by the ${MAX_LIVE_WORKER_CONTEXT_BYTES}-byte limit. Use worker_status once for diagnostics/recovery to inspect omitted worker IDs and current state; do not poll.`,
+    );
+  }
+  if (pendingResultCount > 0) {
+    sections.push(
+      `Pending delivery: ${pendingResultCount} settled worker result${pendingResultCount === 1 ? "" : "s"} await automatic delivery. Do not redispatch that work.`,
+    );
+  }
+
+  const guidance: string[] = [];
+  if (activeCount > 0) {
+    guidance.push(
+      "Do not duplicate active assignments. Wait for automatic result delivery; do not poll worker_status for completion.",
+    );
+  }
+  if (readyCount > 0) {
+    guidance.push(
+      "Ready interactive sessions are retained: use interactive_send with the worker_id for follow-up, or interactive_close when finished.",
+    );
+  }
+  guidance.push(
+    "Use worker_status only for diagnostics or recovery when this snapshot reports overflow or state appears inconsistent.",
+  );
+  sections.push(`Guidance:\n- ${guidance.join("\n- ")}`);
+
+  return sections.join("\n\n");
+}
+
+function normalizeText(value: string): string {
+  return value.replace(/\s+/gu, " ").trim();
+}
+
+function quote(value: string): string {
+  return JSON.stringify(value);
+}
+
+function normalizeCount(value: number): number {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+
+function utf8Bytes(value: string): number {
+  return Buffer.byteLength(value, "utf8");
+}
+
+function capUtf8(value: string, byteLimit: number, marker: string): string {
+  if (utf8Bytes(value) <= byteLimit) return value;
+  const markerBytes = utf8Bytes(marker);
+  if (markerBytes >= byteLimit) return truncateUtf8(marker, byteLimit);
+  return `${truncateUtf8(value, byteLimit - markerBytes)}${marker}`;
+}
+
+function truncateUtf8(value: string, byteLimit: number): string {
+  if (byteLimit <= 0) return "";
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.byteLength <= byteLimit) return value;
+
+  let end = byteLimit;
+  while (end > 0 && (bytes[end] ?? 0) >> 6 === 0b10) end -= 1;
+  return bytes.subarray(0, end).toString("utf8");
+}

package/extension/worker/session.ts

@@ -674,7 +674,14 @@ const prepareChildModelRuntime = Effect.fn("WorkerSession.prepareChildModelRunti
       yield* Effect.tryPromise({
         try: async () => {
           if (auth.headers) {
-            modelRuntime.registerProvider(selected.provider, { headers: { ...auth.headers } });
+            // Provider config accepts resolved values, not request-only null suppressions;
+            // the child runtime derives those again from the provider's auth implementation.
+            const headers = Object.fromEntries(
+              Object.entries(auth.headers).filter(
+                (entry): entry is [string, string] => entry[1] !== null,
+              ),
+            );
+            modelRuntime.registerProvider(selected.provider, { headers });
           }
           if (auth.apiKey && !options.modelRegistry.isUsingOAuth(model)) {
             await modelRuntime.setRuntimeApiKey(selected.provider, auth.apiKey);
@@ -869,8 +876,8 @@ export const createWorkerSession = Effect.fn("WorkerSession.create")(function* (
     const services = yield* acquireWorkerServices(options, dependencies, modelRuntime);
 
     // createAgentSessionServices registers extension providers and refreshes, but
-    // discards that result in Pi 0.80.10. Keep this worker-owned probe so provider
-    // errors and aborts remain typed acquisition failures; remove it when Pi surfaces them.
+    // does not surface the refresh result. Keep this worker-owned probe so provider
+    // errors and aborts remain typed acquisition failures.
     yield* refreshModelRuntime(modelRuntime, definition);
     const model = yield* Effect.try({
       try: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zachwill/pi-orchestrate",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "description": "Concurrent worker orchestration for Pi",
   "exports": {},
@@ -29,17 +29,18 @@
     "effect": "4.0.0-rc.111"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "^0.80.10",
-    "@earendil-works/pi-ai": "^0.80.10",
-    "@earendil-works/pi-coding-agent": "^0.80.10",
-    "@earendil-works/pi-tui": "^0.80.10",
+    "@earendil-works/pi-agent-core": "^0.85.0",
+    "@earendil-works/pi-ai": "^0.85.0",
+    "@earendil-works/pi-coding-agent": "^0.85.0",
+    "@earendil-works/pi-tui": "^0.85.0",
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.80.10",
-    "@earendil-works/pi-ai": "0.80.10",
-    "@earendil-works/pi-coding-agent": "0.80.10",
-    "@earendil-works/pi-tui": "0.80.10",
+    "@earendil-works/pi-agent-core": "0.85.0",
+    "@earendil-works/pi-ai": "0.85.0",
+    "@earendil-works/pi-coding-agent": "0.85.0",
+    "@earendil-works/pi-server": "0.85.0",
+    "@earendil-works/pi-tui": "0.85.0",
     "@types/bun": "^1.3.14",
     "@types/node": "^22.19.17",
     "typebox": "^1.1.37",