@zachwill/pi-orchestrate 0.15.0 → 0.17.0

package/README.md

@@ -6,13 +6,21 @@
 - Workers run independently and return their results to the parent.
 - Only the parent can delegate; workers cannot create more workers.
 
+Requires Pi 0.85.0 or newer.
+
+```bash
+pi install npm:@zachwill/pi-orchestrate
+```
+
 ## The model
 
 Each `orchestrate` dispatch creates a fresh worker session with its own transcript. The worker receives a complete brief from the parent but not the parent's conversation.
 
-A worker definition is reusable configuration: it selects the worker's prompt, tools, lifecycle, and optional model settings. It is not a running or retained session.
+A worker definition is reusable configuration for the worker's prompt, tools, lifecycle, and optional model settings. The parent remains responsible for the user's complete requested outcome across its own and worker work.
+
+Workers run in the background. `orchestrate` and `interactive_send` return acceptance so the parent can continue useful independent work, including tool calls dispatched alongside the workers. Worker dispatches in the same response form one result group; dispatches in later responses form separate groups.
 
-Independent workers dispatched together run concurrently. Their results return only to the parent session that started them, and the parent synthesizes the group after every worker finishes. A rejected or failed worker does not cancel its peers. Orchestration dispatched alongside unrelated tool calls runs inline instead of in the background.
+Results return only to the parent session that started the workers. Results that settle while the parent is busy are queued. After the parent run ends normally, individual results can enter its context as they arrive; a dispatch group resumes the parent after every admitted member settles. The parent can do useful independent work before ending its run, or end promptly when progress needs worker evidence. A rejected, failed, or aborted worker does not cancel its peers; stopping other active workers requires an explicit `worker_abort` request.
 
 Workers have one of two lifecycles:
 
@@ -23,6 +31,8 @@ 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.
 
+Workers keep running when the parent conversation is compacted, and their results return automatically. Restarting Pi does not restore running workers.
+
 ## Agent interface
 
 Pi Orchestrate gives the parent five model-facing tools:
@@ -35,11 +45,11 @@ Pi Orchestrate gives the parent five model-facing tools:
 | `worker_abort` | Stop active workers owned by the parent |
 | `worker_status` | Inspect the trusted catalog and diagnose the parent's worker state |
 
-The extension supplies the parent with the exact dispatch and lifecycle rules for these tools. The README describes their behavior rather than duplicating those model instructions.
+The extension supplies the parent with instructions for using these tools.
 
 ## Worker definitions
 
-The package includes four fallback definitions in [`examples/workers/`](examples/workers/): `scout` for small factual probes, `investigator` for read-only cross-file research, `worker` for bounded implementation, and `web` for public web research. The first three inherit the parent's active model. The `web` worker uses the model declared in its definition and requires an installed, authenticated Codex CLI.
+The package includes four fallback definitions in [`examples/workers/`](examples/workers/): `scout` for small factual probes, `investigator` for read-only cross-file research, `worker` for bounded implementation, and `web` for public web research. The fallbacks use `openai-codex/gpt-6-sol`, except `scout`, which uses `openai-codex/gpt-6-luna`. The `web` worker also requires an installed, authenticated Codex CLI.
 
 Definitions are loaded by name in this precedence order:
 
@@ -77,8 +87,6 @@ The frontmatter is strict:
 
 The Markdown body is the worker's nonempty system prompt. `tools` and `skills` accept either YAML arrays or comma-separated strings. Supported Pi tools are `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls`. Unknown fields and malformed definitions are rejected and appear in catalog diagnostics.
 
-Each `orchestrate` call starts a new worker session from the selected definition. Only `interactive_send` continues an existing session.
-
 ## Trust boundary
 
 Workers run in the parent process and are not security sandboxes. They share its filesystem and environment permissions.
@@ -87,6 +95,4 @@ Workers can use global Pi settings, authentication, packages, extensions, skills
 
 A definition's `tools` field controls Pi's tool allowlist, not operating-system authority. A worker with `bash` can start external processes, including other agent CLIs. A read-only prompt also does not prevent writes when the worker has a write-capable tool.
 
-Concurrent workers share the same working tree, so overlapping write scopes can collide. The parent owns the outcome, works directly, and delegates independent parts when doing so improves speed or quality. The parent integrates worker results and checks the evidence behind consequential claims or changes, adding independent review when a specific risk warrants it.
-
-Pi Orchestrate excludes itself from child sessions and keeps workers as direct Pi children.
+Concurrent workers share the same working tree, so overlapping write scopes can collide.

package/examples/workers/investigator.md

@@ -1,15 +1,14 @@
 ---
 name: investigator
-description: Investigates cross-file questions and synthesizes grounded evidence.
-thinking: medium
+description: Investigates cross-file questions through read-only inspection and evidence-based synthesis.
+model: openai-codex/gpt-6-sol
+thinking: high
 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,14 @@
 ---
 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.
+model: openai-codex/gpt-6-luna
+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

@@ -1,26 +1,20 @@
 ---
 name: web
 description: Researches the public web with one or more Codex searches and returns a source-grounded synthesis.
-model: openai-codex/gpt-5.6-sol
+model: openai-codex/gpt-6-sol
 thinking: medium
 tools: bash
 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.
 
@@ -37,7 +31,7 @@ stderr_log="$work_dir/stderr.log"
 
 codex exec - \
   --ignore-user-config \
-  --model gpt-5.6-sol \
+  --model gpt-6-sol \
   -c 'model_reasoning_effort="medium"' \
   -c 'web_search="cached"' \
   --ephemeral \
@@ -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,18 @@
 ---
 name: worker
-description: Implements a bounded change within explicit scope and acceptance criteria.
+description: Implements bounded code changes, fixes, and refactors.
+model: openai-codex/gpt-6-sol
 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,
@@ -80,7 +84,7 @@ export function createOrchestrationExtension(
         orchestration: host.orchestration,
         getCatalog: catalogFor,
         getDispatchDecision: (toolCallId) =>
-          dispatchDecisions.get(toolCallId) ?? { mode: "inline" },
+          dispatchDecisions.get(toolCallId) ?? {},
       });
       hostAttachment ??= attachProcessHost(host);
 
@@ -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/orchestration/service.ts

@@ -376,14 +376,13 @@ class OrchestrationEngine implements OrchestrationService {
       const runId = this.idFactories.runId();
       const completion = yield* Deferred.make<CompletedRun>();
       const now = this.clock.currentTimeMillisUnsafe();
-      const runRecord: RunRecord = {
-        id: runId,
-        ownerSessionId: context.ownerSessionId,
-        workerId: validatedWorkerId,
+      const runRecord = makeRunRecord(
+        runId,
+        validatedWorkerId,
+        context,
         mode,
-        state: "running",
-        createdAt: now,
-      };
+        now,
+      );
 
       const admission = this.transact((draft) => {
         const ready = readyInteractiveDecision(

package/extension/parent/contract.ts

@@ -96,43 +96,35 @@ function buildContract(catalog: WorkerCatalog): string {
   return `${CONTRACT_START}
 ## Pi Orchestrate Contract
 
-You are responsible for delivering the user’s requested outcome. Work directly and use workers where parallel ownership or specialized judgment materially helps. Own the difficult decisions, shared problems, and final answer.
+You own the user’s outcome across parent and worker work. Exercise judgment: use workers when they help, continue useful work yourself, and deliver one coherent answer.
 
-### Scope
+### Outcome and scope
 
-- Scope comes from the user’s request and applicable instructions. Preserve explicitly broad tasks, but do not broaden narrow tasks because execution reveals related work.
-- Understand the requested outcome and take the next concrete step. Keep planning proportional to dependencies and risk; do not require a written scope statement, roster, or approval checkpoint unless it resolves a real ambiguity.
-- Necessary investigation and implementation details belong to the task. Separate optional improvements from the requested work; ask before making consequential changes beyond it.
-- Admit newly discovered work only when the current change would otherwise be incorrect, unsafe, nonfunctional, or unverifiable. If that work exceeds the boundary, narrow, revert, or ask the user rather than silently expanding.
-- Do not introduce cross-feature policy, infrastructure, deployment, or compatibility work unless the request or an unavoidable requirement of the current change calls for it.
-- Completed worker effort does not justify retaining an overgrown change set.
+- Preserve the requested scope, completeness, and form. Do not silently substitute an easier deliverable, narrow a broad request to a sample, or treat checks against a selected subset as evidence that the full requirement is satisfied.
+- Do the investigation and implementation needed for the outcome, but do not invent adjacent deliverables, policies, or cleanup. Ask when a material ambiguity or consequential out-of-scope change requires the user’s authority.
+- Assign write ownership so concurrent scopes are disjoint. Give one owner any shared file or integration point, and preserve changes you do not own.
 
 ### Delegation
 
-- Delegate substantive, independent parts of the problem when doing so improves speed or quality. Prefer end-to-end assignments: each worker investigates what its question requires, does the work, and checks its result. The parent should solve useful parts of the problem directly rather than defaulting to a coordination-only role.
-- Respect the user’s requested workers and counts. Otherwise choose the smallest team that usefully advances the outcome. Do not add roles merely because preparation, implementation, and review can be separated.
-- Each \`orchestrate\` call creates a fresh worker session. The same worker definition and identical brief may be used for independent judgments; do not vary briefs merely to make them appear different. Interactive follow-up continues one worker ID with its existing context.
-- Give every worker a self-contained brief with its objective, context, owned paths, forbidden changes, success criteria, expected output, and stop condition. Instruct workers to report adjacent findings without fixing them. Workers do not receive the parent conversation.
+- Delegate separable work when the expected improvement in quality or latency is worth the coordination cost. Respect worker choices and counts requested by the user; otherwise choose from the work rather than applying a minimum, maximum, or mandatory role pattern.
+- Give each worker enough context to own one outcome and scope boundary, including relevant constraints, owned paths, and consequential evidence checks. Workers do not receive the parent conversation. Have them report out-of-scope findings instead of fixing them.
+- **Important:** When independent worker assignments are ready, dispatch them using one \`multi_tool_use.parallel\` call containing every \`functions.orchestrate\` call. Do not dispatch one worker first and batch the rest afterward.
+- Each \`orchestrate\` call creates a fresh worker session. Interactive follow-up uses \`interactive_send\` with the existing worker ID and context; close a ready interactive worker with \`interactive_close\` when it is no longer needed.
 
-### Parallel dispatch
+### Dispatch and dependencies
 
-- Form the complete wave before emitting any tool call. “Complete” means every worker admitted for the current change and turn, not every potentially useful concern.
-- For one worker, make one fully briefed \`orchestrate\` call. For N workers where N > 1, make exactly one \`multi_tool_use.parallel\` call containing exactly N \`functions.orchestrate\` entries and no other tools.
-- If \`multi_tool_use.parallel\` is unavailable, emit all N \`orchestrate\` calls as native siblings in one assistant response.
-- Never split a multi-worker wave across assistant responses; an admitted sole asynchronous \`orchestrate\` call ends the parent turn.
-- The expanded tool-call group must contain only the intended \`orchestrate\` calls. Mixing another tool into the group makes orchestration inline and blocking.
+- \`orchestrate\` and \`interactive_send\` start background work and return acceptance without ending the parent run, including alongside other tools. Worker dispatches in the same response are grouped for result delivery; dispatches in later responses form separate groups.
+- After dispatch, continue useful independent work. When that work is exhausted or progress needs worker evidence, end the run normally so automatic result delivery can resume you. A brief truthful pending-status response is acceptable; do not claim final completion before necessary results are considered.
+- Do not poll \`worker_status\`, sleep, duplicate active assignments, or invent work while results are pending. Do not force parent work when none is useful, and do not stop before doing independent work that materially advances the outcome.
+- Results that settle while the parent is busy are queued and delivered when the parent run ends. Do not redispatch queued work.
+- Compaction does not stop workers. Use the fresh live-worker snapshot for active assignments and ready interactive sessions rather than stale conversation summaries. Do not redispatch work because its dispatch was compacted away. Use \`worker_status\` once only for diagnostics or recovery when the snapshot overflows or state appears inconsistent.
 
 ### 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.
-- 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.
-- Inspect worker results and check the evidence behind consequential claims or changes. Add independent review when a specific risk warrants it, not as an automatic phase. Reuse credible verification already performed; investigate gaps and contradictions.
-- Inspect the combined result and worker evidence, resolve disagreements, and accept, reduce, or discard the change. Do not personally repeat delegated review or verification without a concrete reason.
-- Verification decides whether to accept the change; it is not a general source of new work. Fix failures caused by the change, but narrow, revert, report, or ask when verification demands unrelated work.
-- Stop when the acceptance criteria pass. Report delivered work separately from findings deliberately left outside scope.
-- Prefer one-shot workers. Use interactive workers only when retained context is useful and follow the lifecycle requirements in the tool descriptions.
+- Treat worker reports as input, not the answer. Resolve material conflicts and assess the combined result against the original request; a worker’s local success does not redefine completion.
+- Check consequential claims, changes, and failure modes with evidence suited to the task. Add review or integration tests only when a concrete risk warrants them, and do not repeat credible worker checks without a reason.
+- Do not give the final answer until every worker result necessary to the outcome has been delivered and considered. Report completed work and any unresolved or out-of-scope finding directly.
+- Use \`worker_abort\` only to stop active owned work. Ending the parent run, compaction, and closing a ready interactive session do not cancel other workers.
 
 ### Trusted worker catalog
 

package/extension/parent/delivery.ts

@@ -7,9 +7,10 @@ export const MAX_WORKER_DELIVERY_MARKDOWN_BYTES = 16 * 1024;
 export const DELIVERY_TRUNCATION_MARKER =
   "\n\n[Worker result truncated for parent context. Full output remains in structured details.]";
 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.";
+  "Parent: Use these results as input to the user's task. Resolve material conflicts, check consequential evidence, and complete the requested outcome; do not merely forward worker reports or reopen work that is already satisfied.";
 
 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/dispatch-policy.ts

@@ -6,7 +6,6 @@ export interface ParentToolCall {
 }
 
 export interface DispatchDecision {
-  readonly mode: "async" | "inline";
   readonly synthesisGroup?: SynthesisGroup;
 }
 
@@ -20,30 +19,21 @@ const DISPATCH_TOOL_NAMES: ReadonlySet<string> = new Set([
   "interactive_send",
 ]);
 
-// Sole dispatches and homogeneous orchestrate waves detach so the parent turn can
-// end while work continues. Mixed tools stay inline because their shared parent
-// turn still has sibling work; one wave boundary defers one synthesis turn until
-// every admitted member has settled.
+// Every public dispatch detaches so sibling parent tools can finish independently.
+// Dispatches from one assistant response share a synthesis boundary; ordinary
+// sibling tools are neither group members nor part of its expected size.
 export function classifyParentDispatches(
   toolCalls: readonly ParentToolCall[],
 ): readonly ClassifiedParentDispatch[] {
-  const isOrchestrateGroup =
-    toolCalls.length > 1 &&
-    toolCalls.every((toolCall) => toolCall.name === "orchestrate");
-  const synthesisGroup = isOrchestrateGroup
-    ? { id: `orchestrate:${toolCalls[0]?.id ?? "group"}`, size: toolCalls.length }
+  const dispatches = toolCalls.filter((toolCall) =>
+    DISPATCH_TOOL_NAMES.has(toolCall.name)
+  );
+  const synthesisGroup = dispatches.length > 1
+    ? { id: `dispatch:${dispatches[0]!.id}`, size: dispatches.length }
     : undefined;
 
-  return toolCalls.flatMap((toolCall): ClassifiedParentDispatch[] => {
-    if (!DISPATCH_TOOL_NAMES.has(toolCall.name)) return [];
-    return [{
-      toolCallId: toolCall.id,
-      decision: {
-        mode: isOrchestrateGroup || toolCalls.length === 1 ? "async" : "inline",
-        ...(toolCall.name === "orchestrate" && synthesisGroup
-          ? { synthesisGroup }
-          : {}),
-      },
-    }];
-  });
+  return dispatches.map((toolCall) => ({
+    toolCallId: toolCall.id,
+    decision: synthesisGroup ? { synthesisGroup } : {},
+  }));
 }

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. Continue useful independent work when it materially advances the outcome.",
+    );
+  }
+  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(
+    "Settled results are delivered automatically after the parent run ends. If progress depends on pending evidence, end the run truthfully rather than polling. 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/pi/tools.ts

@@ -1,4 +1,3 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type {
   ExtensionAPI,
   ExtensionContext,
@@ -28,10 +27,7 @@ import type {
 } from "../orchestration/admission.ts";
 import type {
   AcceptedRun,
-  CompletedRun,
   OwnerSnapshot,
-  SettlementListener,
-  WorkerRunResult,
 } from "../orchestration/service.ts";
 import type { DispatchDecision } from "../parent/dispatch-policy.ts";
 import type { OrchestrationClient } from "../parent/process-host.ts";
@@ -42,11 +38,6 @@ import {
   workerAbortToolRenderer,
   workerStatusToolRenderer,
 } from "./tool-renderer.ts";
-import {
-  encodeInlineWorkerToolDetails,
-  type InlineWorkerSettlementDetails,
-  type WorkerSettlement,
-} from "../orchestration/settlement.ts";
 
 const STRICT_OBJECT = { additionalProperties: false } as const;
 const shortTextSchema = Type.String({
@@ -114,45 +105,30 @@ export function registerOrchestrationTools(
     name: "orchestrate",
     label: "Orchestrate",
     description:
-      "Dispatch fully briefed worker scopes. Pi executes native sibling tools concurrently; Pi Orchestrate treats a successfully admitted sole orchestrate call or pure sibling group as async. Mixing orchestrate with another tool makes it inline and blocking.",
-    promptSnippet: "Dispatch fully briefed parallel worker scopes",
+      "Dispatch one fully briefed worker scope in the background. All orchestrate and interactive_send calls in the same assistant response form one result group; ordinary sibling tools execute concurrently and are not group members.",
+    promptSnippet: "Dispatch one fully briefed worker scope in the background",
     promptGuidelines: [
-      "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.",
-      "For an intended async wave of N workers, the next assistant response must contain exactly N separate, fully briefed orchestrate calls; one call is valid only when N=1. To run it asynchronously, include no other tool calls; harmless response text does not affect runtime classification.",
-      "When a parallel tool dispatcher is available, use it once with exactly N orchestrate entries and no other tools; for example, put N functions.orchestrate entries in multi_tool_use.parallel. Otherwise emit N native sibling orchestrate calls in one assistant response.",
-      "Form all N calls before emitting or finalizing the response. Never emit one call and wait for its result before forming the rest of the wave: a successfully admitted sole async orchestrate call returns terminate=true and ends the turn.",
+      "orchestrate starts background work and returns acceptance without ending the parent run. Dispatch siblings in one assistant response share a result group; ordinary sibling tools do not join that group.",
     ],
     executionMode: "parallel",
     parameters: taskSchema,
     ...orchestrateToolRenderer,
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params, signal, _onUpdate, ctx) {
       const decision = deps.getDispatchDecision(toolCallId);
-      const mode = decision.mode;
-      const orchestrationContext = buildOrchestrationContext(ctx, deps, decision.synthesisGroup);
-      if (mode === "async") {
-        const acceptedRun = await deps.orchestration.orchestrate(
-          orchestrationContext,
-          params,
-          "async",
-          signal,
-        );
-        const readable = acceptedRunSummary(acceptedRun);
-        return {
-          ...readableToolResult(`Accepted async run ${readable.run_id}.`, readable),
-          terminate: true,
-        };
-      }
-
-      const completedRun = await deps.orchestration.orchestrate(
+      const orchestrationContext = buildOrchestrationContext(
+        ctx,
+        deps,
+        decision.synthesisGroup,
+      );
+      const acceptedRun = await deps.orchestration.orchestrate(
         orchestrationContext,
         params,
-        "inline",
+        "async",
         signal,
-        createInlineSettlementListener(onUpdate),
       );
-      const readable = completedRunSummary(completedRun);
+      const readable = acceptedRunSummary(acceptedRun);
       return readableToolResult(
-        `Completed inline run ${readable.run_id}.`,
+        `Accepted async run ${readable.run_id}.`,
         readable,
       );
     },
@@ -185,43 +161,31 @@ export function registerOrchestrationTools(
     name: "interactive_send",
     label: "Interactive Send",
     description:
-      "Send follow-up instructions only to an owned lifecycle interactive worker whose status is ready. Never use for one-shot or completed workers; one-shot sessions terminate automatically. A sole tool call runs asynchronously; sibling tool calls make it inline and blocking.",
+      "Send background follow-up instructions only to an owned lifecycle interactive worker whose status is ready. All interactive_send and orchestrate calls in the same assistant response form one result group; ordinary sibling tools execute concurrently and are not group members. Never use for one-shot or completed workers.",
     promptSnippet: "Use only for an owned lifecycle interactive worker with status ready; never one-shot/completed because one-shot sessions terminate automatically",
     promptGuidelines: [
-      "Use interactive_send only for an owned lifecycle interactive worker whose status is ready; never use it for one-shot or completed workers because one-shot sessions terminate automatically.",
+      "interactive_send starts background follow-up work and returns acceptance without ending the parent run. Dispatch siblings in one assistant response share a result group; ordinary sibling tools do not join that group.",
     ],
     parameters: interactiveSendSchema,
     ...interactiveSendToolRenderer,
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
+    async execute(toolCallId, params, signal, _onUpdate, ctx) {
       const workerId = params.worker_id;
-      const mode = deps.getDispatchDecision(toolCallId).mode;
-      const orchestrationContext = buildOrchestrationContext(ctx, deps);
-      if (mode === "async") {
-        const acceptedRun = await deps.orchestration.sendInteractive(
-          orchestrationContext,
-          workerId,
-          params.instructions,
-          "async",
-          signal,
-        );
-        const readable = acceptedRunSummary(acceptedRun);
-        return {
-          ...readableToolResult(`Accepted async run ${readable.run_id}.`, readable),
-          terminate: true,
-        };
-      }
-
-      const completedRun = await deps.orchestration.sendInteractive(
+      const decision = deps.getDispatchDecision(toolCallId);
+      const orchestrationContext = buildOrchestrationContext(
+        ctx,
+        deps,
+        decision.synthesisGroup,
+      );
+      const acceptedRun = await deps.orchestration.sendInteractive(
         orchestrationContext,
         workerId,
         params.instructions,
-        "inline",
+        "async",
         signal,
-        createInlineSettlementListener(onUpdate),
       );
-      const readable = completedRunSummary(completedRun);
+      const readable = acceptedRunSummary(acceptedRun);
       return readableToolResult(
-        `Completed inline run ${readable.run_id}.`,
+        `Accepted async run ${readable.run_id}.`,
         readable,
       );
     },
@@ -289,20 +253,6 @@ function buildOrchestrationContext(
   };
 }
 
-function createInlineSettlementListener(
-  onUpdate: ((result: AgentToolResult<unknown>) => void) | undefined,
-): SettlementListener {
-  return (settlement) => {
-    onUpdate?.({
-      content: [{ type: "text", text: "Worker response received." }],
-      details: encodeInlineWorkerToolDetails({
-        mode: "inline",
-        result: inlineResultValue(settlement),
-      }),
-    });
-  };
-}
-
 function normalizeAbortTarget(params: {
   worker_ids?: string[];
   all?: boolean;
@@ -321,33 +271,6 @@ function acceptedRunSummary(run: AcceptedRun) {
   };
 }
 
-function completedRunSummary(run: CompletedRun) {
-  return encodeInlineWorkerToolDetails({
-    mode: "inline",
-    runId: run.id,
-    ownerSessionId: run.ownerSessionId,
-    result: inlineResultValue(run.result),
-  });
-}
-
-function inlineResultValue(
-  result: WorkerRunResult | WorkerSettlement,
-): InlineWorkerSettlementDetails {
-  return {
-    workerId: result.workerId,
-    worker: result.worker,
-    title: result.title,
-    status: result.status,
-    outcome: result.outcome,
-    usage: result.usage,
-    startedAt: result.startedAt,
-    settledAt: result.settledAt,
-    ...(result.sessionFile === undefined
-      ? {}
-      : { sessionFile: result.sessionFile }),
-  };
-}
-
 function statusSummary(catalog: WorkerCatalog, snapshot: OwnerSnapshot) {
   return {
     catalog: {

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.17.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",