@zachwill/pi-orchestrate 0.9.0 → 0.10.0

package/extension/{worker-session.ts → worker/session.ts}

@@ -1,6 +1,5 @@
 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 {
@@ -20,26 +19,22 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   Cause,
-  Context,
-  Deferred,
   Effect,
   Exit,
-  FiberSet,
-  Layer,
   Schema,
   Scope,
-  SynchronizedRef,
 } from "effect";
+import type { WorkerDefinition } from "../catalog/definition.js";
 import type {
-  WorkerDefinition,
   WorkerMessageDirection,
   WorkerOutcome,
   WorkerUsage,
-} from "./domain.js";
+} from "../orchestration/model.js";
+import { PACKAGE_ROOT } from "../package-root.js";
 
 const DIRECT_CHILD_BOUNDARY =
   "You are a direct child worker session. Do not spawn, delegate to, or orchestrate descendant Pi worker 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)));
+const ORCHESTRATE_PACKAGE_ROOT = canonicalPath(PACKAGE_ROOT);
 
 interface WorkerAgentSession {
   readonly sessionFile: string | undefined;
@@ -131,11 +126,6 @@ export class WorkerAgentSessionAcquisitionError extends Schema.TaggedError<Worke
   { operation: WorkerAgentSessionAcquisitionOperation, message: Schema.String, cause: Schema.Defect() },
 ) {}
 
-export class WorkerSessionAcquisitionClosedError extends Schema.TaggedError<WorkerSessionAcquisitionClosedError>()(
-  "WorkerSession.AcquisitionClosedError",
-  { message: Schema.String },
-) {}
-
 const WorkerSessionAbortOperation = Schema.Literals([
   "abort-compaction",
   "abort-prompt",
@@ -155,29 +145,10 @@ export class WorkerSessionAbortError extends Schema.TaggedError<WorkerSessionAbo
   },
 ) {}
 
-export type WorkerSessionAcquisitionError =
+export type WorkerSessionCreationError =
   | WorkerModelAcquisitionError
   | WorkerResourceAcquisitionError
-  | WorkerAgentSessionAcquisitionError
-  | WorkerSessionAcquisitionClosedError;
-
-export interface ChildSessionsService {
-  /**
-   * Acquires a child session through a process-owned producer. The adopter must
-   * synchronously install ownership before returning a value. Returning undefined
-   * rejects adoption and leaves ChildSessions responsible for disposal.
-   */
-  readonly acquire: <Adopted>(
-    options: ChildSessionOptions,
-    adopt: (session: WorkerSessionHandle) => Adopted | undefined,
-  ) => Effect.Effect<Adopted | undefined, WorkerSessionAcquisitionError>;
-  /** Closes every handoff without waiting for uncancellable Pi calls. */
-  readonly shutdown: () => Effect.Effect<void>;
-}
-
-export class ChildSessions extends Context.Service<ChildSessions, ChildSessionsService>()(
-  "@zachwill/pi-orchestrate/ChildSessions",
-) {}
+  | WorkerAgentSessionAcquisitionError;
 
 const WorkerSessionCleanupOperation = Schema.Literals([
   "unsubscribe",
@@ -249,7 +220,12 @@ export interface WorkerSessionDependencies {
   onReclamationOpenObserved(): Effect.Effect<void>;
 }
 
-const defaultDependencies: WorkerSessionDependencies = {
+type WorkerSessionAcquisitionDependencies = Omit<
+  WorkerSessionDependencies,
+  "beforeAdoptionReservation" | "onReclamationOpenObserved"
+>;
+
+const defaultWorkerSessionDependencies: WorkerSessionAcquisitionDependencies = {
   createSettingsManager: ({ cwd, agentDir, projectTrusted, compaction }) => {
     const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
     if (compaction !== undefined) settingsManager.applyOverrides({ compaction: { ...compaction } });
@@ -279,8 +255,6 @@ const defaultDependencies: WorkerSessionDependencies = {
       detail: `Operation: ${operation}`,
     });
   },
-  beforeAdoptionReservation: () => Effect.void,
-  onReclamationOpenObserved: () => Effect.void,
 };
 
 function canonicalPath(path: string): string {
@@ -656,7 +630,7 @@ const refreshModelRuntime = Effect.fn("WorkerSession.refreshModelRuntime")(funct
 
 const prepareChildModelRuntime = Effect.fn("WorkerSession.prepareChildModelRuntime")(function* (
   options: ChildSessionOptions,
-  dependencies: WorkerSessionDependencies,
+  dependencies: WorkerSessionAcquisitionDependencies,
 ) {
   const selected = yield* Effect.try({
     try: () => selectedModelCoordinates(options.definition, options.parentModel),
@@ -749,7 +723,7 @@ const disposeWorkerSession = Effect.fn("WorkerSession.dispose")(function* (
 
 const acquireWorkerServices = Effect.fn("WorkerSession.acquireServices")(function* (
   options: ChildSessionOptions,
-  dependencies: WorkerSessionDependencies,
+  dependencies: WorkerSessionAcquisitionDependencies,
   modelRuntime: ModelRuntime,
 ) {
   const definition = options.definition;
@@ -825,7 +799,7 @@ function agentSessionFinalizer(
 }
 
 const acquireAgentSession = Effect.fn("WorkerSession.acquireAgentSession")(function* (
-  dependencies: WorkerSessionDependencies,
+  dependencies: WorkerSessionAcquisitionDependencies,
   input: AgentSessionInput,
 ) {
   return yield* Effect.acquireRelease(
@@ -844,7 +818,7 @@ const acquireAgentSession = Effect.fn("WorkerSession.acquireAgentSession")(funct
 });
 
 const acquireAgentSessionRuntime = Effect.fn("WorkerSession.acquireAgentSessionRuntime")(function* (
-  dependencies: WorkerSessionDependencies,
+  dependencies: WorkerSessionAcquisitionDependencies,
   ownership: AgentSessionOwnership,
   services: AgentSessionServices,
 ) {
@@ -857,7 +831,7 @@ const acquireAgentSessionRuntime = Effect.fn("WorkerSession.acquireAgentSessionR
 });
 
 const acquireSessionSubscription = Effect.fn("WorkerSession.acquireSubscription")(function* (
-  dependencies: WorkerSessionDependencies,
+  dependencies: WorkerSessionAcquisitionDependencies,
   runtime: OwnedWorkerRuntime,
   handle: DefaultWorkerSessionHandle,
 ) {
@@ -874,10 +848,14 @@ const acquireSessionSubscription = Effect.fn("WorkerSession.acquireSubscription"
   );
 });
 
-const createWorkerSession = Effect.fn("WorkerSession.create")(function* (
+export const createWorkerSession = Effect.fn("WorkerSession.create")(function* (
   options: ChildSessionOptions,
-  dependencies: WorkerSessionDependencies,
+  overrides: Partial<WorkerSessionDependencies>,
 ) {
+  const dependencies: WorkerSessionAcquisitionDependencies = {
+    ...defaultWorkerSessionDependencies,
+    ...overrides,
+  };
   const scope = yield* Scope.make("sequential");
   const acquisition = Effect.gen(function* () {
     const definition = options.definition;
@@ -969,245 +947,3 @@ const createWorkerSession = Effect.fn("WorkerSession.create")(function* (
     ),
   );
 });
-
-type AcquisitionHandoffState =
-  | { readonly _tag: "Pending" }
-  | { readonly _tag: "Offered"; readonly session: WorkerSessionHandle }
-  | { readonly _tag: "Adopting"; readonly session: WorkerSessionHandle }
-  | { readonly _tag: "Adopted" }
-  | { readonly _tag: "Abandoned"; readonly error?: WorkerSessionAcquisitionClosedError }
-  | { readonly _tag: "Failed" };
-
-interface AcquisitionHandoff {
-  readonly state: SynchronizedRef.SynchronizedRef<AcquisitionHandoffState>;
-  readonly result: Deferred.Deferred<WorkerSessionHandle, WorkerSessionAcquisitionError>;
-}
-
-type ChildSessionsState =
-  | { readonly _tag: "Open"; readonly handoffs: ReadonlySet<AcquisitionHandoff> }
-  | { readonly _tag: "Closed"; readonly error: WorkerSessionAcquisitionClosedError };
-
-type AdoptionReservation =
-  | { readonly _tag: "Reserved"; readonly session: WorkerSessionHandle }
-  | { readonly _tag: "Closed"; readonly error: WorkerSessionAcquisitionClosedError }
-  | { readonly _tag: "Abandoned" };
-
-function disposeLateSession(session: WorkerSessionHandle): Effect.Effect<void> {
-  return session.dispose().pipe(Effect.catchCause(() => Effect.void));
-}
-
-function admitReclamationOrJoinAfterClosure(
-  fibers: FiberSet.FiberSet<void, never>,
-  reclamation: Effect.Effect<void>,
-  onOpenObserved: () => Effect.Effect<void>,
-): Effect.Effect<void> {
-  return Effect.suspend(() => {
-    if (fibers.state._tag === "Closed") return reclamation;
-    return Effect.gen(function* () {
-      yield* onOpenObserved().pipe(Effect.catchCause(() => Effect.void));
-      yield* FiberSet.run(fibers, reclamation, { startImmediately: true });
-      if (fibers.state._tag === "Closed") {
-        // FiberSet.run returns an interrupted sentinel when closure wins admission.
-        // If admission won, closure interrupts the admitted fiber instead. Real
-        // session disposal is cached and uninterruptible, so this fallback safely
-        // joins that same disposal in both cases rather than starting cleanup twice.
-        yield* reclamation;
-      }
-    });
-  });
-}
-
-export function createChildSessionsLayer(
-  overrides: Partial<WorkerSessionDependencies> = {},
-): Layer.Layer<ChildSessions> {
-  return Layer.effect(
-    ChildSessions,
-    Effect.gen(function* () {
-      const dependencies: WorkerSessionDependencies = { ...defaultDependencies, ...overrides };
-      const fibers = yield* FiberSet.make<void, never>();
-      const serviceState = yield* SynchronizedRef.make<ChildSessionsState>({
-        _tag: "Open",
-        handoffs: new Set(),
-      });
-
-      const withoutHandoff = (
-        state: ChildSessionsState,
-        handoff: AcquisitionHandoff,
-      ): ChildSessionsState => {
-        if (state._tag === "Closed" || !state.handoffs.has(handoff)) return state;
-        const handoffs = new Set(state.handoffs);
-        handoffs.delete(handoff);
-        return { _tag: "Open", handoffs };
-      };
-
-      const removeHandoff = (handoff: AcquisitionHandoff): Effect.Effect<void> =>
-        SynchronizedRef.update(serviceState, (state) => withoutHandoff(state, handoff));
-
-      const runReclamation = (session: WorkerSessionHandle): Effect.Effect<void> =>
-        admitReclamationOrJoinAfterClosure(
-          fibers,
-          disposeLateSession(session).pipe(Effect.uninterruptible),
-          dependencies.onReclamationOpenObserved,
-        );
-
-      const abandonHandoff = Effect.fn("ChildSessions.abandonHandoff")(function* (
-        handoff: AcquisitionHandoff,
-      ) {
-        const session = yield* SynchronizedRef.modifyEffect(serviceState, (service) => {
-          const nextService = withoutHandoff(service, handoff);
-          return SynchronizedRef.modify(handoff.state, (state): readonly [
-            { readonly session: WorkerSessionHandle | undefined },
-            AcquisitionHandoffState,
-          ] => {
-            if (state._tag === "Pending") {
-              return [{ session: undefined }, { _tag: "Abandoned" }];
-            }
-            if (state._tag === "Offered") {
-              return [{ session: state.session }, { _tag: "Abandoned" }];
-            }
-            return [{ session: undefined }, state];
-          }).pipe(Effect.map(({ session }) => [session, nextService] as const));
-        });
-        if (session) yield* runReclamation(session);
-      });
-
-      const shutdown = Effect.fn("ChildSessions.shutdown")(() =>
-        Effect.gen(function* () {
-          const closed = yield* SynchronizedRef.modifyEffect(serviceState, (state) => {
-            if (state._tag === "Closed") return Effect.succeed([undefined, state] as const);
-            const error = new WorkerSessionAcquisitionClosedError({
-              message: "Child sessions are shutting down",
-            });
-            return Effect.gen(function* () {
-              const sessions: WorkerSessionHandle[] = [];
-              for (const handoff of state.handoffs) {
-                const session = yield* SynchronizedRef.modifyEffect(handoff.state, (handoffState) => {
-                  if (handoffState._tag === "Pending") {
-                    return Deferred.fail(handoff.result, error).pipe(
-                      Effect.as([undefined, { _tag: "Abandoned", error }] as const),
-                    );
-                  }
-                  if (handoffState._tag === "Offered") {
-                    return Effect.succeed([
-                      handoffState.session,
-                      { _tag: "Abandoned", error },
-                    ] as const);
-                  }
-                  // Failed already settled its Deferred. Adopting is an ownership
-                  // reservation whose synchronous winner must be allowed to commit.
-                  return Effect.succeed([undefined, handoffState] as const);
-                });
-                if (session) sessions.push(session);
-              }
-              return [{ sessions }, { _tag: "Closed", error }] as const;
-            });
-          });
-          if (!closed) return;
-          for (const session of closed.sessions) yield* runReclamation(session);
-        }).pipe(Effect.uninterruptible)
-      );
-
-      yield* Effect.addFinalizer(() => shutdown());
-
-      const acquire = Effect.fn("ChildSessions.acquire")(function* <Adopted>(
-        options: ChildSessionOptions,
-        adopt: (session: WorkerSessionHandle) => Adopted | undefined,
-      ) {
-        const handoff: AcquisitionHandoff = {
-          state: yield* SynchronizedRef.make<AcquisitionHandoffState>({ _tag: "Pending" }),
-          result: yield* Deferred.make<WorkerSessionHandle, WorkerSessionAcquisitionError>(),
-        };
-        return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-          const admissionError = yield* SynchronizedRef.modify(serviceState, (state) => {
-            if (state._tag === "Closed") return [state.error, state] as const;
-            return [undefined, {
-              _tag: "Open",
-              handoffs: new Set([...state.handoffs, handoff]),
-            }] as const;
-          });
-          if (admissionError) return yield* Effect.fail(admissionError);
-
-          const producer = createWorkerSession(options, dependencies).pipe(
-            Effect.matchCauseEffect({
-              onFailure: (cause) => Effect.gen(function* () {
-                const failed = yield* SynchronizedRef.modifyEffect(handoff.state, (state) =>
-                  state._tag === "Pending"
-                    ? Deferred.failCause(handoff.result, cause).pipe(
-                        Effect.as([true, { _tag: "Failed" }] as const),
-                      )
-                    : Effect.succeed([false, state] as const));
-                if (failed) yield* removeHandoff(handoff);
-              }),
-              onSuccess: (session) => Effect.gen(function* () {
-                const offered = yield* SynchronizedRef.modifyEffect(handoff.state, (state) =>
-                  state._tag === "Pending"
-                    ? Deferred.succeed(handoff.result, session).pipe(
-                        Effect.as([true, { _tag: "Offered", session }] as const),
-                      )
-                    : Effect.succeed([false, state] as const));
-                if (!offered) {
-                  yield* removeHandoff(handoff);
-                  yield* runReclamation(session);
-                }
-              }),
-            }),
-            Effect.uninterruptible,
-          );
-          yield* FiberSet.run(fibers, producer, { startImmediately: true });
-
-          const session = yield* restore(
-            Deferred.await(handoff.result).pipe(
-              Effect.tap(() => dependencies.beforeAdoptionReservation()),
-            ),
-          ).pipe(Effect.onInterrupt(() => abandonHandoff(handoff)));
-          const reservation = yield* SynchronizedRef.modifyEffect(serviceState, (service) => {
-            if (service._tag === "Closed") {
-              return Effect.succeed([
-                { _tag: "Closed", error: service.error } satisfies AdoptionReservation,
-                service,
-              ] as const);
-            }
-            return SynchronizedRef.modify(
-              handoff.state,
-              (state): readonly [AdoptionReservation, AcquisitionHandoffState] => {
-                if (state._tag === "Abandoned") {
-                  return state.error
-                    ? [{ _tag: "Closed", error: state.error }, state]
-                    : [{ _tag: "Abandoned" }, state];
-                }
-                if (state._tag !== "Offered" || state.session !== session) {
-                  return [{ _tag: "Abandoned" }, state];
-                }
-                return [
-                  { _tag: "Reserved", session },
-                  { _tag: "Adopting", session },
-                ];
-              },
-            ).pipe(Effect.map((result) => [result, service] as const));
-          });
-          if (reservation._tag === "Closed") return yield* Effect.fail(reservation.error);
-          if (reservation._tag === "Abandoned") {
-            return yield* Effect.die(new Error("Child session acquisition handoff was abandoned"));
-          }
-
-          // The adopter is arbitrary synchronous runtime code. The reservation
-          // protects it from shutdown, but no SynchronizedRef semaphore is held.
-          const adopted = yield* Effect.exit(Effect.sync(() => adopt(reservation.session)));
-          const transferred = Exit.isSuccess(adopted) && adopted.value !== undefined;
-          yield* SynchronizedRef.update(handoff.state, (state): AcquisitionHandoffState => {
-            if (state._tag !== "Adopting" || state.session !== reservation.session) return state;
-            return transferred ? { _tag: "Adopted" } : { _tag: "Abandoned" };
-          });
-          yield* removeHandoff(handoff);
-          if (transferred) return adopted.value;
-
-          yield* runReclamation(reservation.session);
-          if (Exit.isFailure(adopted)) return yield* Effect.failCause(adopted.cause);
-          return undefined;
-        }));
-      });
-
-      return ChildSessions.of({ acquire, shutdown });
-    }),
-  );
-}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@zachwill/pi-orchestrate",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "Concurrent worker orchestration for Pi",
+  "exports": {},
   "files": ["extension/", "examples/", "README.md", "LICENSE"],
   "keywords": ["pi-package", "pi", "workers", "orchestration"],
   "license": "MIT",