@zachwill/pi-orchestrate 0.1.1 → 0.2.1

package/extension/worker-session.ts

@@ -1,21 +1,34 @@
-import { join } from "node:path";
+import { realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
 import {
-  createAgentSession,
-  DefaultResourceLoader,
+  AgentSessionRuntime,
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+  DefaultPackageManager,
   ModelRuntime,
   type ModelRegistry,
   type ResourceLoader,
   SessionManager,
   SettingsManager,
   type AgentSessionEvent,
-  type CreateAgentSessionOptions,
+  type AgentSessionServices,
+  type CreateAgentSessionResult,
+  type DefaultResourceLoader,
 } from "@earendil-works/pi-coding-agent";
-import type { WorkerDefinition, WorkerOutcome, WorkerUsage } from "./domain.js";
+import { Effect, Exit, Schema, Scope } from "effect";
+import type {
+  WorkerDefinition,
+  WorkerMessageDirection,
+  WorkerOutcome,
+  WorkerUsage,
+} from "./domain.js";
 
 const DIRECT_CHILD_BOUNDARY =
   "You are a direct child worker session. Do not spawn, delegate to, or orchestrate other workers or child sessions. Complete the assigned task yourself and return the result directly to the parent orchestrator.";
+const ORCHESTRATE_PACKAGE_ROOT = canonicalPath(fileURLToPath(new URL("..", import.meta.url)));
 
 interface WorkerAgentSession {
   readonly sessionFile: string | undefined;
@@ -23,11 +36,19 @@ interface WorkerAgentSession {
   prompt(instructions: string): Promise<void>;
   abort(): Promise<void>;
   dispose(): void;
+  bindExtensions(bindings: { mode: "print" }): Promise<void>;
   subscribe(listener: (event: AgentSessionEvent) => void): () => void;
 }
 
-type ResourceLoaderOptions = ConstructorParameters<typeof DefaultResourceLoader>[0];
-type InMemorySettings = Parameters<typeof SettingsManager.inMemory>[0];
+interface OwnedWorkerRuntime {
+  readonly session: WorkerAgentSession;
+  dispose(): Promise<void>;
+}
+
+type ResourceLoaderOptions = Omit<
+  ConstructorParameters<typeof DefaultResourceLoader>[0],
+  "cwd" | "agentDir" | "settingsManager"
+>;
 
 export interface WorkerSessionFactoryOptions {
   cwd: string;
@@ -44,18 +65,42 @@ export interface WorkerSessionHandle {
   readonly sessionFile: string;
   prompt(instructions: string): Promise<WorkerOutcome>;
   abort(): Promise<void>;
-  dispose(): void;
+  dispose(): Promise<void>;
   subscribeUsage(listener: (usage: WorkerUsage) => void): () => void;
   subscribeActivity(listener: (activity: string | undefined) => void): () => void;
+  subscribeMessageDirection(listener: (direction: WorkerMessageDirection) => void): () => void;
 }
 
 export interface WorkerSessionFactory {
   create(options: WorkerSessionFactoryOptions): Promise<WorkerSessionHandle>;
 }
 
-interface SessionManagerInput {
+export class WorkerModelAcquisitionError extends Schema.TaggedErrorClass<WorkerModelAcquisitionError>()(
+  "WorkerSession.ModelAcquisitionError",
+  { message: Schema.String, cause: Schema.Defect() },
+) {}
+
+export class WorkerResourceAcquisitionError extends Schema.TaggedErrorClass<WorkerResourceAcquisitionError>()(
+  "WorkerSession.ResourceAcquisitionError",
+  { message: Schema.String, cause: Schema.Defect() },
+) {}
+
+export class WorkerAgentSessionAcquisitionError extends Schema.TaggedErrorClass<WorkerAgentSessionAcquisitionError>()(
+  "WorkerSession.AgentSessionAcquisitionError",
+  { message: Schema.String, cause: Schema.Defect() },
+) {}
+
+interface SettingsManagerInput {
   cwd: string;
-  parentSessionFile: string | undefined;
+  agentDir: string;
+  projectTrusted: boolean;
+  compaction: WorkerDefinition["compaction"];
+}
+
+interface ExtensionPathInput {
+  cwd: string;
+  agentDir: string;
+  settingsManager: SettingsManager;
 }
 
 interface ModelRuntimeInput {
@@ -63,38 +108,61 @@ interface ModelRuntimeInput {
   modelsPath: string;
 }
 
-interface AgentSessionInput {
+interface ServicesInput {
   cwd: string;
   agentDir: string;
-  model: Model<Api>;
+  settingsManager: SettingsManager;
   modelRuntime: ModelRuntime;
+  resourceLoaderOptions: ResourceLoaderOptions;
+}
+
+interface AgentSessionInput {
+  services: AgentSessionServices;
+  sessionManager: SessionManager;
+  model: Model<Api>;
   thinkingLevel: ThinkingLevel | undefined;
   tools: string[];
-  resourceLoader: ResourceLoader;
-  sessionManager: unknown;
-  settingsManager: unknown;
+}
+
+interface RuntimeInput {
+  session: WorkerAgentSession;
+  services: AgentSessionServices;
 }
 
 export interface WorkerSessionDependencies {
-  createResourceLoader(options: ResourceLoaderOptions): ResourceLoader;
-  createSessionManager(input: SessionManagerInput): unknown;
-  createSettingsManager(
-    settings: InMemorySettings,
-    options: { projectTrusted: boolean },
-  ): unknown;
+  createSettingsManager(input: SettingsManagerInput): SettingsManager;
+  resolveExtensionPaths(input: ExtensionPathInput): Promise<readonly string[]>;
+  createSessionManager(input: { cwd: string; parentSessionFile: string | undefined }): SessionManager;
   createModelRuntime(input: ModelRuntimeInput): Promise<ModelRuntime>;
+  createServices(input: ServicesInput): Promise<AgentSessionServices>;
   createAgentSession(input: AgentSessionInput): Promise<{ session: WorkerAgentSession }>;
+  createRuntime(input: RuntimeInput): OwnedWorkerRuntime;
 }
 
 const defaultDependencies: WorkerSessionDependencies = {
-  createResourceLoader: (options) => new DefaultResourceLoader(options),
+  createSettingsManager: ({ cwd, agentDir, projectTrusted, compaction }) => {
+    const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
+    if (compaction !== undefined) settingsManager.applyOverrides({ compaction: { ...compaction } });
+    return settingsManager;
+  },
+  resolveExtensionPaths: async ({ cwd, agentDir, settingsManager }) => {
+    const resolved = await new DefaultPackageManager({ cwd, agentDir, settingsManager }).resolve();
+    return resolved.extensions.filter((entry) => entry.enabled).map((entry) => entry.path);
+  },
   createSessionManager: ({ cwd, parentSessionFile }) =>
     SessionManager.create(cwd, undefined, { parentSession: parentSessionFile }),
-  createSettingsManager: (settings, options) =>
-    SettingsManager.inMemory(settings, { projectTrusted: options.projectTrusted }),
   createModelRuntime: (input) => ModelRuntime.create(input),
+  createServices: (input) => createAgentSessionServices(input),
   createAgentSession: (input) =>
-    createAgentSession(input as CreateAgentSessionOptions) as Promise<{ session: WorkerAgentSession }>,
+    createAgentSessionFromServices(input) as Promise<CreateAgentSessionResult & { session: WorkerAgentSession }>,
+  createRuntime: ({ session, services }) =>
+    new AgentSessionRuntime(
+      session as CreateAgentSessionResult["session"],
+      services,
+      async () => {
+        throw new Error("Worker sessions do not support runtime replacement");
+      },
+    ) as unknown as OwnedWorkerRuntime,
 };
 
 export function resolveWorkerModel(
@@ -119,57 +187,34 @@ export function resolveWorkerModel(
   return model;
 }
 
-interface DisposableResource {
-  dispose(): void;
-}
-
-function isDisposableResource(resource: ResourceLoader): resource is ResourceLoader & DisposableResource {
-  return "dispose" in resource && typeof resource.dispose === "function";
-}
-
-function disposeResourceLoader(resourceLoader: ResourceLoader): void {
-  if (!isDisposableResource(resourceLoader)) return;
+function canonicalPath(path: string): string {
   try {
-    resourceLoader.dispose();
+    return realpathSync.native(path);
   } catch {
-    // Cleanup is best-effort and must not hide the original failure.
+    return resolve(path);
   }
 }
 
-function disposeSession(session: WorkerAgentSession): void {
-  try {
-    session.dispose();
-  } catch {
-    // Other owned resources still need to be released.
-  }
+function isWithin(path: string, root: string): boolean {
+  const child = relative(root, path);
+  return child === "" || (!child.startsWith("..") && !isAbsolute(child));
 }
 
-function describePromptError(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string" && error !== "") return error;
-  return "Worker prompt failed";
+export function isOrchestrationExtensionPath(path: string): boolean {
+  return isWithin(canonicalPath(path), ORCHESTRATE_PACKAGE_ROOT);
 }
 
-interface MutableWorkerUsage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  cost: number;
-  contextTokens: number;
-  turns: number;
+function resourceLoaderFinalizer(resourceLoader: ResourceLoader): Effect.Effect<void> {
+  return Effect.sync(() => {
+    if (!("dispose" in resourceLoader) || typeof resourceLoader.dispose !== "function") return;
+    resourceLoader.dispose();
+  }).pipe(Effect.ignoreCause);
 }
 
-function emptyUsage(): MutableWorkerUsage {
-  return {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    cost: 0,
-    contextTokens: 0,
-    turns: 0,
-  };
+function describeError(error: unknown, fallback: string): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string" && error !== "") return error;
+  return fallback;
 }
 
 function assistantText(message: AssistantMessage | undefined): string | undefined {
@@ -188,184 +233,157 @@ function lastAssistant(messages: AgentMessage[]): AssistantMessage | undefined {
   return undefined;
 }
 
+interface MutableWorkerUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  contextTokens: number;
+  turns: number;
+}
+
+function emptyUsage(): MutableWorkerUsage {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+}
+
 class DefaultWorkerSessionHandle implements WorkerSessionHandle {
   readonly sessionFile: string;
-
   private readonly usage = emptyUsage();
   private readonly usageListeners = new Set<(usage: WorkerUsage) => void>();
-  private readonly activityListeners = new Set<
-    (activity: string | undefined) => void
-  >();
-  private readonly unsubscribeSession: () => void;
+  private readonly activityListeners = new Set<(activity: string | undefined) => void>();
+  private readonly messageDirectionListeners = new Set<(direction: WorkerMessageDirection) => void>();
+  private readonly activeToolCalls = new Map<string, string>();
   private disposed = false;
+  private disposePromise: Promise<void> | undefined;
   private activity: string | undefined;
-  private readonly activeToolCalls = new Map<string, string>();
+  private messageDirection: WorkerMessageDirection | undefined;
   private prompting = false;
   private abortRequested = false;
   private promptAssistant: AssistantMessage | undefined;
 
   constructor(
-    private readonly session: WorkerAgentSession,
-    private readonly resourceLoader: ResourceLoader,
+    private readonly runtime: OwnedWorkerRuntime,
     private readonly reusable: boolean,
+    sessionFile: string,
+    private readonly scope: Scope.Closeable,
   ) {
-    this.sessionFile = session.sessionFile!;
-    this.unsubscribeSession = session.subscribe((event) => this.onSessionEvent(event));
+    this.sessionFile = sessionFile;
   }
 
-  private onSessionEvent(event: AgentSessionEvent): void {
+  receiveSessionEvent(event: AgentSessionEvent): void {
+    if (event.type === "message_start") {
+      if (event.message.role === "assistant") this.setMessageDirection("from-model");
+      else if (event.message.role === "user" || event.message.role === "toolResult") this.setMessageDirection("to-model");
+      return;
+    }
     if (event.type === "tool_execution_start") {
       this.activeToolCalls.delete(event.toolCallId);
       this.activeToolCalls.set(event.toolCallId, event.toolName);
       this.setActivity(event.toolName);
       return;
     }
-
     if (event.type === "tool_execution_end") {
       if (this.activeToolCalls.get(event.toolCallId) !== event.toolName) return;
       this.activeToolCalls.delete(event.toolCallId);
-      this.setActivity(this.mostRecentActiveTool());
+      this.setActivity([...this.activeToolCalls.values()].at(-1));
       return;
     }
-
     if (event.type !== "turn_end" || event.message.role !== "assistant") return;
-
-    const message = event.message;
-    this.promptAssistant = message;
-    this.usage.input += message.usage.input ?? 0;
-    this.usage.output += message.usage.output ?? 0;
-    this.usage.cacheRead += message.usage.cacheRead ?? 0;
-    this.usage.cacheWrite += message.usage.cacheWrite ?? 0;
-    this.usage.cost += message.usage.cost?.total ?? 0;
-    this.usage.contextTokens = message.usage.totalTokens ?? 0;
+    this.promptAssistant = event.message;
+    this.usage.input += event.message.usage.input ?? 0;
+    this.usage.output += event.message.usage.output ?? 0;
+    this.usage.cacheRead += event.message.usage.cacheRead ?? 0;
+    this.usage.cacheWrite += event.message.usage.cacheWrite ?? 0;
+    this.usage.cost += event.message.usage.cost?.total ?? 0;
+    this.usage.contextTokens = event.message.usage.totalTokens ?? 0;
     this.usage.turns += 1;
-
-    for (const listener of [...this.usageListeners]) {
-      try {
-        listener({ ...this.usage });
-      } catch {
-        // One subscriber cannot prevent other subscribers from receiving usage.
-      }
-    }
-  }
-
-  private mostRecentActiveTool(): string | undefined {
-    let latest: string | undefined;
-    for (const toolName of this.activeToolCalls.values()) latest = toolName;
-    return latest;
+    for (const listener of [...this.usageListeners]) safelyNotify(() => listener({ ...this.usage }));
   }
 
   private setActivity(activity: string | undefined): void {
     if (this.activity === activity) return;
     this.activity = activity;
-    for (const listener of [...this.activityListeners]) {
-      try {
-        listener(activity);
-      } catch {
-        // One subscriber cannot prevent other subscribers from receiving activity.
-      }
-    }
+    for (const listener of [...this.activityListeners]) safelyNotify(() => listener(activity));
+  }
+
+  private setMessageDirection(direction: WorkerMessageDirection): void {
+    if (this.messageDirection === direction) return;
+    this.messageDirection = direction;
+    for (const listener of [...this.messageDirectionListeners]) safelyNotify(() => listener(direction));
   }
 
   async prompt(instructions: string): Promise<WorkerOutcome> {
     if (this.disposed) throw new Error("Worker session has been disposed");
     if (this.prompting) throw new Error("Worker session is already processing a prompt");
-
     this.prompting = true;
     this.abortRequested = false;
     this.promptAssistant = undefined;
-    const previousAssistant = lastAssistant(this.session.messages);
-
+    this.setMessageDirection("to-model");
+    const previousAssistant = lastAssistant(this.runtime.session.messages);
+    let failureMessage: string | undefined;
     try {
-      await this.session.prompt(instructions);
-      const latestAssistant = lastAssistant(this.session.messages);
-      const message = this.promptAssistant ?? (latestAssistant !== previousAssistant ? latestAssistant : undefined);
-      return this.outcomeFrom(message);
+      await this.runtime.session.prompt(instructions);
     } catch (error) {
-      const latestAssistant = lastAssistant(this.session.messages);
-      const message = this.promptAssistant ?? (latestAssistant !== previousAssistant ? latestAssistant : undefined);
-      return this.outcomeFrom(message, describePromptError(error));
+      failureMessage = describeError(error, "Worker prompt failed");
     } finally {
       this.prompting = false;
     }
-  }
-
-  private outcomeFrom(
-    message: AssistantMessage | undefined,
-    failureMessage?: string,
-  ): WorkerOutcome {
+    const latestAssistant = lastAssistant(this.runtime.session.messages);
+    const message = this.promptAssistant ?? (latestAssistant !== previousAssistant ? latestAssistant : undefined);
     const text = assistantText(message);
     const assistantPayload = text === undefined ? {} : { assistantText: text };
-
     if (this.abortRequested || message?.stopReason === "aborted") {
       const abortMessage = message?.errorMessage ?? failureMessage;
-      return {
-        status: "aborted",
-        ...(abortMessage === undefined ? {} : { message: abortMessage }),
-        ...assistantPayload,
-      };
+      return { status: "aborted", ...(abortMessage ? { message: abortMessage } : {}), ...assistantPayload };
     }
-
     if (message?.stopReason === "error") {
-      return {
-        status: "failed",
-        message: message.errorMessage ?? failureMessage ?? "Worker assistant reported a failure",
-        ...assistantPayload,
-      };
-    }
-
-    if (failureMessage !== undefined) {
-      return { status: "failed", message: failureMessage, ...assistantPayload };
+      return { status: "failed", message: message.errorMessage ?? failureMessage ?? "Worker assistant reported a failure", ...assistantPayload };
     }
-
-    return {
-      status: this.reusable ? "ready" : "completed",
-      assistantText: text ?? "",
-    };
+    if (failureMessage) return { status: "failed", message: failureMessage, ...assistantPayload };
+    return { status: this.reusable ? "ready" : "completed", assistantText: text ?? "" };
   }
 
   async abort(): Promise<void> {
     if (this.prompting) this.abortRequested = true;
-    await this.session.abort();
+    await this.runtime.session.abort();
   }
 
-  dispose(): void {
-    if (this.disposed) return;
-    this.disposed = true;
+  dispose(): Promise<void> {
+    if (this.disposePromise) return this.disposePromise;
 
-    try {
-      this.unsubscribeSession();
-    } catch {
-      // Continue releasing independently owned resources.
-    }
+    this.disposed = true;
     this.activeToolCalls.clear();
     this.usageListeners.clear();
     this.activityListeners.clear();
-    disposeSession(this.session);
-    disposeResourceLoader(this.resourceLoader);
+    this.messageDirectionListeners.clear();
+    this.disposePromise = Effect.runPromise(disposeWorkerSession(this.scope));
+    return this.disposePromise;
   }
 
   subscribeUsage(listener: (usage: WorkerUsage) => void): () => void {
-    this.usageListeners.add(listener);
-    let subscribed = true;
-    return () => {
-      if (!subscribed) return;
-      subscribed = false;
-      this.usageListeners.delete(listener);
-    };
+    return subscribe(this.usageListeners, listener);
   }
-
-  subscribeActivity(
-    listener: (activity: string | undefined) => void,
-  ): () => void {
-    this.activityListeners.add(listener);
-    let subscribed = true;
-    return () => {
-      if (!subscribed) return;
-      subscribed = false;
-      this.activityListeners.delete(listener);
-    };
+  subscribeActivity(listener: (activity: string | undefined) => void): () => void {
+    return subscribe(this.activityListeners, listener);
   }
+  subscribeMessageDirection(listener: (direction: WorkerMessageDirection) => void): () => void {
+    return subscribe(this.messageDirectionListeners, listener);
+  }
+}
+
+function safelyNotify(callback: () => void): void {
+  try { callback(); } catch { /* One cleanup/listener cannot block another. */ }
+}
+
+function subscribe<T>(listeners: Set<(value: T) => void>, listener: (value: T) => void): () => void {
+  listeners.add(listener);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    listeners.delete(listener);
+  };
 }
 
 function selectedModelCoordinates(
@@ -374,158 +392,333 @@ function selectedModelCoordinates(
 ): { provider: string; modelId: string } {
   if (definition.model) return definition.model;
   if (parentModel) return { provider: parentModel.provider, modelId: parentModel.id };
-  throw new Error(
-    `Worker "${definition.name}" has no configured model and no parent model is available`,
-  );
+  throw new Error(`Worker "${definition.name}" has no configured model and no parent model is available`);
+}
+
+function modelAcquisitionError(cause: unknown, fallback: string): WorkerModelAcquisitionError {
+  return new WorkerModelAcquisitionError({ message: describeError(cause, fallback), cause });
+}
+
+function resourceAcquisitionError(cause: unknown): WorkerResourceAcquisitionError {
+  return new WorkerResourceAcquisitionError({
+    message: describeError(cause, "Worker resource acquisition failed"),
+    cause,
+  });
+}
+
+function agentSessionAcquisitionError(cause: unknown): WorkerAgentSessionAcquisitionError {
+  return new WorkerAgentSessionAcquisitionError({
+    message: describeError(cause, "Worker agent session acquisition failed"),
+    cause,
+  });
 }
 
-async function refreshChildModelRuntime(
+const refreshModelRuntime = Effect.fn("WorkerSession.refreshModelRuntime")(function* (
   modelRuntime: ModelRuntime,
   definition: WorkerDefinition,
-): Promise<void> {
-  const result = await modelRuntime.refresh({ allowNetwork: false });
+) {
+  const result = yield* Effect.tryPromise({
+    try: () => modelRuntime.refresh({ allowNetwork: false }),
+    catch: (cause) => modelAcquisitionError(cause, "Worker model refresh failed"),
+  });
   if (result.errors.size > 0) {
-    const errors = [...result.errors]
-      .map(([providerId, error]) => `${providerId}: ${error.message}`)
-      .join("; ");
-    throw new Error(
+    const errors = [...result.errors].map(([id, error]) => `${id}: ${error.message}`).join("; ");
+    const cause = new Error(
       `Worker "${definition.name}" failed to refresh child model providers: ${errors}`,
     );
+    return yield* Effect.fail(modelAcquisitionError(cause, "Worker model refresh failed"));
   }
   if (result.aborted) {
-    throw new Error(`Worker "${definition.name}" child model refresh was aborted`);
+    const cause = new Error(`Worker "${definition.name}" child model refresh was aborted`);
+    return yield* Effect.fail(modelAcquisitionError(cause, "Worker model refresh failed"));
   }
-}
+});
 
-async function prepareChildModelRuntime(
+const prepareChildModelRuntime = Effect.fn("WorkerSession.prepareChildModelRuntime")(function* (
   options: WorkerSessionFactoryOptions,
   dependencies: WorkerSessionDependencies,
-): Promise<{ model: Model<Api>; modelRuntime: ModelRuntime }> {
-  const selected = selectedModelCoordinates(options.definition, options.parentModel);
-  const modelRuntime = await dependencies.createModelRuntime({
-    authPath: join(options.agentDir, "auth.json"),
-    modelsPath: join(options.agentDir, "models.json"),
+) {
+  const selected = yield* Effect.try({
+    try: () => selectedModelCoordinates(options.definition, options.parentModel),
+    catch: (cause) => modelAcquisitionError(cause, "Worker model selection failed"),
+  });
+  const modelRuntime = yield* Effect.tryPromise({
+    try: () => dependencies.createModelRuntime({
+      authPath: join(options.agentDir, "auth.json"),
+      modelsPath: join(options.agentDir, "models.json"),
+    }),
+    catch: (cause) => modelAcquisitionError(cause, "Worker model runtime creation failed"),
   });
 
-  for (const providerId of options.modelRegistry.getRegisteredProviderIds()) {
-    const providerConfig = options.modelRegistry.getRegisteredProviderConfig(providerId);
-    if (providerConfig) modelRuntime.registerProvider(providerId, { ...providerConfig });
-  }
-  await refreshChildModelRuntime(modelRuntime, options.definition);
-
-  const initiallyResolvedModel = modelRuntime.getModel(selected.provider, selected.modelId);
-  if (!initiallyResolvedModel) {
-    throw new Error(
-      `Worker "${options.definition.name}" configured model "${selected.provider}/${selected.modelId}" was not found`,
-    );
-  }
+  yield* Effect.try({
+    try: () => {
+      for (const providerId of options.modelRegistry.getRegisteredProviderIds()) {
+        const config = options.modelRegistry.getRegisteredProviderConfig(providerId);
+        if (config) modelRuntime.registerProvider(providerId, { ...config });
+      }
+    },
+    catch: (cause) => modelAcquisitionError(cause, "Worker model provider registration failed"),
+  });
+  yield* refreshModelRuntime(modelRuntime, options.definition);
 
-  const resolvedAuth = await options.modelRegistry.getApiKeyAndHeaders(initiallyResolvedModel);
-  const parentUsesOAuth = options.modelRegistry.isUsingOAuth(initiallyResolvedModel);
-  if (resolvedAuth.ok) {
-    if (resolvedAuth.headers) {
-      modelRuntime.registerProvider(selected.provider, {
-        headers: { ...resolvedAuth.headers },
+  const model = yield* Effect.try({
+    try: () => modelRuntime.getModel(selected.provider, selected.modelId),
+    catch: (cause) => modelAcquisitionError(cause, "Worker model resolution failed"),
+  });
+  if (model) {
+    const auth = yield* Effect.tryPromise({
+      try: () => options.modelRegistry.getApiKeyAndHeaders(model),
+      catch: (cause) => modelAcquisitionError(cause, "Worker model authentication failed"),
+    });
+    if (auth.ok) {
+      yield* Effect.tryPromise({
+        try: async () => {
+          if (auth.headers) {
+            modelRuntime.registerProvider(selected.provider, { headers: { ...auth.headers } });
+          }
+          if (auth.apiKey && !options.modelRegistry.isUsingOAuth(model)) {
+            await modelRuntime.setRuntimeApiKey(selected.provider, auth.apiKey);
+          }
+        },
+        catch: (cause) => modelAcquisitionError(cause, "Worker model runtime key setup failed"),
       });
     }
-    // OAuth resolution returns an access token through the compatibility API, but
-    // installing that token as a runtime API key masks the complete OAuth credential
-    // that the child already reads from the shared auth.json file.
-    if (resolvedAuth.apiKey && !parentUsesOAuth) {
-      await modelRuntime.setRuntimeApiKey(selected.provider, resolvedAuth.apiKey);
-    }
-    // Pi 0.80.10 exposes resolved provider env here but has no public ModelRuntime
-    // runtime-env setter. Provider registrations, resolved headers, and non-OAuth
-    // API keys are copied.
   }
 
-  await refreshChildModelRuntime(modelRuntime, options.definition);
-  const model = modelRuntime.getModel(selected.provider, selected.modelId);
-  if (!model) {
-    throw new Error(
-      `Worker "${options.definition.name}" configured model "${selected.provider}/${selected.modelId}" was not found`,
-    );
-  }
-  return { model, modelRuntime };
+  return { selected, modelRuntime };
+});
+
+function skillLoaderOptions(definition: WorkerDefinition): Pick<ResourceLoaderOptions, "noSkills" | "skillsOverride"> {
+  if (definition.skills === undefined) return {};
+  const selectedSkills = new Set(definition.skills);
+  return {
+    noSkills: selectedSkills.size === 0,
+    skillsOverride: (base) => ({
+      skills: base.skills.filter((skill) => selectedSkills.has(skill.name)),
+      diagnostics: base.diagnostics,
+    }),
+  };
 }
 
-export function createWorkerSessionFactory(
-  dependencies: WorkerSessionDependencies = defaultDependencies,
-): WorkerSessionFactory {
+function contextLoaderOptions(
+  agentDir: string,
+  projectTrusted: boolean,
+): Pick<ResourceLoaderOptions, "agentsFilesOverride"> {
+  if (projectTrusted) return {};
+  const globalRoot = canonicalPath(agentDir);
   return {
-    async create(options) {
-      const definition = options.definition;
-      const { model, modelRuntime } = await prepareChildModelRuntime(options, dependencies);
-      const selectedSkills = new Set(definition.skills);
-      const settingsManager = dependencies.createSettingsManager(
-        definition.compaction === undefined
-          ? undefined
-          : { compaction: { ...definition.compaction } },
-        { projectTrusted: options.projectTrusted },
-      );
-      const resourceLoader = dependencies.createResourceLoader({
+    agentsFilesOverride: (base) => ({
+      agentsFiles: base.agentsFiles.filter((file) => isWithin(canonicalPath(file.path), globalRoot)),
+    }),
+  };
+}
+
+const disposeWorkerSession = Effect.fn("WorkerSession.dispose")(function* (
+  scope: Scope.Closeable,
+) {
+  yield* Scope.close(scope, Exit.void).pipe(Effect.ignoreCause);
+});
+
+const acquireWorkerServices = Effect.fn("WorkerSession.acquireServices")(function* (
+  options: WorkerSessionFactoryOptions,
+  dependencies: WorkerSessionDependencies,
+  modelRuntime: ModelRuntime,
+) {
+  const definition = options.definition;
+  const settingsManager = yield* Effect.try({
+    try: () => dependencies.createSettingsManager({
+      cwd: options.cwd,
+      agentDir: options.agentDir,
+      projectTrusted: options.projectTrusted,
+      compaction: definition.compaction,
+    }),
+    catch: resourceAcquisitionError,
+  });
+  const extensionPaths = yield* Effect.tryPromise({
+    try: () => dependencies.resolveExtensionPaths({
+      cwd: options.cwd,
+      agentDir: options.agentDir,
+      settingsManager,
+    }),
+    catch: resourceAcquisitionError,
+  }).pipe(Effect.map((paths) => paths.filter((path) => !isOrchestrationExtensionPath(path))));
+
+  return yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      // Pi's supported helper constructs and reloads its loader internally. If reload rejects,
+      // it exposes no loader to dispose; callers cannot make that acquisition failure-atomic.
+      try: () => dependencies.createServices({
         cwd: options.cwd,
         agentDir: options.agentDir,
-        settingsManager: settingsManager as SettingsManager,
-        noExtensions: true,
-        noSkills: selectedSkills.size === 0,
-        noPromptTemplates: true,
-        noThemes: true,
-        noContextFiles: !options.projectTrusted,
-        skillsOverride: (base) => ({
-          skills: base.skills.filter((skill) => selectedSkills.has(skill.name)),
-          diagnostics: base.diagnostics,
-        }),
-        appendSystemPrompt: [definition.systemPrompt, DIRECT_CHILD_BOUNDARY],
-      });
+        settingsManager,
+        modelRuntime,
+        resourceLoaderOptions: {
+          noExtensions: true,
+          additionalExtensionPaths: extensionPaths,
+          noPromptTemplates: true,
+          noThemes: true,
+          ...skillLoaderOptions(definition),
+          ...contextLoaderOptions(options.agentDir, options.projectTrusted),
+          appendSystemPrompt: [definition.systemPrompt, DIRECT_CHILD_BOUNDARY],
+        },
+      }),
+      catch: resourceAcquisitionError,
+    }),
+    (services) => resourceLoaderFinalizer(services.resourceLoader),
+  );
+});
 
-      let session: WorkerAgentSession | undefined;
-      try {
-        await resourceLoader.reload();
+interface AgentSessionOwnership {
+  readonly session: WorkerAgentSession;
+  runtime: OwnedWorkerRuntime | undefined;
+}
 
-        const loadedSkillNames = new Set(
-          resourceLoader.getSkills().skills.map((skill) => skill.name),
-        );
-        const missingSkills = [...selectedSkills].filter(
-          (skillName) => !loadedSkillNames.has(skillName),
+function rawSessionFinalizer(session: WorkerAgentSession): Effect.Effect<void> {
+  return Effect.sync(() => session.dispose()).pipe(Effect.ignoreCause);
+}
+
+function agentSessionFinalizer(ownership: AgentSessionOwnership): Effect.Effect<void> {
+  const runtime = ownership.runtime;
+  if (!runtime) return rawSessionFinalizer(ownership.session);
+  return Effect.tryPromise(() => runtime.dispose()).pipe(
+    Effect.catch(() => rawSessionFinalizer(ownership.session)),
+    Effect.ignoreCause,
+  );
+}
+
+const acquireAgentSession = Effect.fn("WorkerSession.acquireAgentSession")(function* (
+  dependencies: WorkerSessionDependencies,
+  input: AgentSessionInput,
+) {
+  return yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      try: () => dependencies.createAgentSession(input),
+      catch: agentSessionAcquisitionError,
+    }).pipe(Effect.map(({ session }) => {
+      const ownership: AgentSessionOwnership = { session, runtime: undefined };
+      return ownership;
+    })),
+    agentSessionFinalizer,
+  );
+});
+
+const acquireAgentSessionRuntime = Effect.fn("WorkerSession.acquireAgentSessionRuntime")(function* (
+  dependencies: WorkerSessionDependencies,
+  ownership: AgentSessionOwnership,
+  services: AgentSessionServices,
+) {
+  const runtime = yield* Effect.try({
+    try: () => dependencies.createRuntime({ session: ownership.session, services }),
+    catch: agentSessionAcquisitionError,
+  });
+  ownership.runtime = runtime;
+  return runtime;
+});
+
+const acquireSessionSubscription = Effect.fn("WorkerSession.acquireSubscription")(function* (
+  runtime: OwnedWorkerRuntime,
+  handle: DefaultWorkerSessionHandle,
+) {
+  return yield* Effect.acquireRelease(
+    Effect.try({
+      try: () => runtime.session.subscribe((event) => handle.receiveSessionEvent(event)),
+      catch: agentSessionAcquisitionError,
+    }),
+    (unsubscribe) => Effect.sync(unsubscribe).pipe(Effect.ignoreCause),
+  );
+});
+
+const createWorkerSession = Effect.fn("WorkerSession.create")(function* (
+  options: WorkerSessionFactoryOptions,
+  dependencies: WorkerSessionDependencies,
+) {
+  const scope = yield* Scope.make("sequential");
+  const acquisition = Effect.gen(function* () {
+    const definition = options.definition;
+    const { selected, modelRuntime } = yield* prepareChildModelRuntime(options, dependencies);
+    const services = yield* acquireWorkerServices(options, dependencies, modelRuntime);
+
+    yield* refreshModelRuntime(modelRuntime, definition);
+    const model = yield* Effect.try({
+      try: () => {
+        const resolvedModel = modelRuntime.getModel(selected.provider, selected.modelId);
+        if (!resolvedModel) {
+          throw new Error(
+            `Worker "${definition.name}" configured model "${selected.provider}/${selected.modelId}" was not found`,
+          );
+        }
+        return resolvedModel;
+      },
+      catch: (cause) => modelAcquisitionError(cause, "Worker model resolution failed"),
+    });
+    const sessionManager = yield* Effect.try({
+      try: () => dependencies.createSessionManager({
+        cwd: options.cwd,
+        parentSessionFile: options.parentSessionFile,
+      }),
+      catch: agentSessionAcquisitionError,
+    });
+    const ownership = yield* acquireAgentSession(dependencies, {
+      services,
+      sessionManager,
+      model,
+      thinkingLevel: definition.thinking,
+      tools: [...definition.tools],
+    });
+    const runtime = yield* acquireAgentSessionRuntime(dependencies, ownership, services);
+    yield* Effect.tryPromise({
+      try: () => runtime.session.bindExtensions({ mode: "print" }),
+      catch: agentSessionAcquisitionError,
+    });
+
+    yield* Effect.try({
+      try: () => {
+        if (definition.skills === undefined) return;
+        const loadedNames = new Set(
+          services.resourceLoader.getSkills().skills.map((skill) => skill.name),
         );
-        if (missingSkills.length > 0) {
+        const missing = definition.skills.filter((name) => !loadedNames.has(name));
+        if (missing.length > 0) {
           throw new Error(
-            `Worker "${definition.name}" selected skills were not loaded: ${missingSkills.join(", ")}`,
+            `Worker "${definition.name}" selected skills were not loaded: ${missing.join(", ")}`,
           );
         }
-
-        const sessionManager = dependencies.createSessionManager({
-          cwd: options.cwd,
-          parentSessionFile: options.parentSessionFile,
-        });
-        ({ session } = await dependencies.createAgentSession({
-          cwd: options.cwd,
-          agentDir: options.agentDir,
-          model,
-          modelRuntime,
-          thinkingLevel: definition.thinking,
-          tools: [...definition.tools],
-          resourceLoader,
-          sessionManager,
-          settingsManager,
-        }));
-        if (!session.sessionFile) {
+      },
+      catch: resourceAcquisitionError,
+    });
+    const sessionFile = yield* Effect.try({
+      try: () => {
+        if (!runtime.session.sessionFile) {
           throw new Error("Worker session was not created with durable storage");
         }
+        return runtime.session.sessionFile;
+      },
+      catch: agentSessionAcquisitionError,
+    });
+
+    const handle = new DefaultWorkerSessionHandle(
+      runtime,
+      definition.lifecycle === "reusable",
+      sessionFile,
+      scope,
+    );
+    yield* acquireSessionSubscription(runtime, handle);
+    return handle;
+  }).pipe(Scope.provide(scope));
+
+  return yield* acquisition.pipe(
+    Effect.catchCause((cause) =>
+      Effect.gen(function* () {
+        yield* Scope.close(scope, Exit.failCause(cause)).pipe(Effect.ignoreCause);
+        return yield* Effect.failCause(cause);
+      })
+    ),
+  );
+});
 
-        const handle = new DefaultWorkerSessionHandle(
-          session,
-          resourceLoader,
-          definition.lifecycle === "reusable",
-        );
-        session = undefined;
-        return handle;
-      } catch (error) {
-        if (session) disposeSession(session);
-        disposeResourceLoader(resourceLoader);
-        throw error;
-      }
-    },
-  };
+export function createWorkerSessionFactory(
+  overrides: Partial<WorkerSessionDependencies> = {},
+): WorkerSessionFactory {
+  const dependencies: WorkerSessionDependencies = { ...defaultDependencies, ...overrides };
+  return { create: (options) => Effect.runPromise(createWorkerSession(options, dependencies)) };
 }