@effect-agent/platform-node 0.1.0-beta.44 → 0.1.0-beta.46

package/src/{layers.ts → NodeDurableAgentRuntime.ts}

@@ -1,4 +1,4 @@
-import type { SubmissionId } from "@effect-agent/core";
+import { type SubmissionId } from "@effect-agent/core/Identifiers";
 import {
   CurrentToolFailureObserver,
   RunContextPreparationPassthrough,
@@ -7,38 +7,47 @@ import {
   type RunContextPreparation,
   type RunCostEstimator,
   type RunToolFailureObserver,
-} from "@effect-agent/engine";
+} from "@effect-agent/engine/RunOptions";
+import { scheduleStoreLayer } from "@effect-agent/storage-sqlite/SqliteScheduleStore";
 import {
-  threadStoreLayer,
-  scheduleStoreLayer,
   SqliteStorageConfig,
   SqliteStorageConfigValue,
+} from "@effect-agent/storage-sqlite/SqliteStorageConfig";
+import { type SqliteStorageFailpointHandler } from "@effect-agent/storage-sqlite/SqliteStorageFailpoint";
+import { submissionLedgerLayer } from "@effect-agent/storage-sqlite/SqliteSubmissionLedger";
+import {
+  threadStoreLayer,
   storageFailpointLayer,
-  submissionLedgerLayer,
-  type SqliteStorageFailpointHandler,
   type SqliteStorageInitializationError,
-} from "@effect-agent/storage-sqlite";
+} from "@effect-agent/storage-sqlite/SqliteThreadStore";
+import {
+  type AgentRegistration,
+  type ResolvedBinding,
+} from "@effect-agent/thread/AgentRegistration";
 import {
-  type ScheduleStore,
-  type ThreadStore,
-  type WakeScheduler,
-  DEFAULT_OWNERSHIP_LEASE_DURATION,
-  DeploymentId,
   DurableAgentRuntime,
   DurableRuntimeConfig,
+} from "@effect-agent/thread/DurableAgentRuntime";
+import {
   DurableRuntimeFailpoint,
-  ProducerId,
+  type DurableRuntimeFailpointHandler,
+} from "@effect-agent/thread/DurableFailpoint";
+import { DeploymentId, ProducerId } from "@effect-agent/thread/Records";
+import { type ScheduleStore } from "@effect-agent/thread/Schedule";
+import {
+  DEFAULT_OWNERSHIP_LEASE_DURATION,
   ReleaseOwnershipRequest,
   SubmissionLedger,
-  ToolReconciler,
-  type DurableRuntimeFailpointHandler,
   type OwnershipToken,
-} from "@effect-agent/thread";
+} from "@effect-agent/thread/SubmissionLedger";
+import { type ThreadStore } from "@effect-agent/thread/ThreadStore";
+import { ToolReconciler } from "@effect-agent/thread/ToolReconciler";
+import { type WakeScheduler } from "@effect-agent/thread/WakeScheduler";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
 import { Context, type Crypto, Duration, Effect, Layer, Ref, Schema } from "effect";
 
-import { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer } from "./wake-scheduler.ts";
+import { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer } from "./NodeWakeScheduler.ts";
 
 const PositiveMillis = Schema.Int.check(Schema.isGreaterThan(0));
 const NonNegativeMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -62,8 +71,8 @@ export class NodePlatformConfigError extends Schema.TaggedError<NodePlatformConf
  * construction, exposed as a typed service). Every cadence is in milliseconds and every bound is
  * finite; `workerConcurrency` caps how many worker loops `NodeDurableHost.runWorkers` drives.
  */
-export class NodeDurableRuntimeConfigValue extends Schema.Class<NodeDurableRuntimeConfigValue>(
-  "@effect-agent/platform-node/NodeDurableRuntimeConfigValue",
+export class NodeDurableAgentRuntimeConfigValue extends Schema.Class<NodeDurableAgentRuntimeConfigValue>(
+  "@effect-agent/platform-node/NodeDurableAgentRuntimeConfigValue",
 )({
   /** SQLite database file backing BOTH the Thread Log and the Submission Ledger. */
   filename: Schema.NonEmptyString,
@@ -90,17 +99,17 @@ export class NodeDurableRuntimeConfigValue extends Schema.Class<NodeDurableRunti
 }) {}
 
 /** Explicit configuration authority for the assembled Node durable runtime. */
-export class NodeDurableRuntimeConfig extends Context.Service<
-  NodeDurableRuntimeConfig,
-  NodeDurableRuntimeConfigValue
->()("@effect-agent/platform-node/NodeDurableRuntimeConfig") {}
+export class NodeDurableAgentRuntimeConfig extends Context.Service<
+  NodeDurableAgentRuntimeConfig,
+  NodeDurableAgentRuntimeConfigValue
+>()("@effect-agent/platform-node/NodeDurableAgentRuntimeConfig") {}
 
 /**
- * Raw (unvalidated) construction options for `NodeDurableRuntime.layer`. Optional fields default
+ * Raw (unvalidated) construction options for `NodeDurableAgentRuntime.layer`. Optional fields default
  * to the documented production values; everything is schema-decoded into
- * `NodeDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
+ * `NodeDurableAgentRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
  */
-export interface NodeDurableRuntimeOptions<
+export interface NodeDurableAgentRuntimeOptions<
   ContextError = never,
   ContextRequirements = never,
   AuthorizationError = never,
@@ -161,25 +170,25 @@ export interface NodeDurableRuntimeOptions<
 }
 
 /** Built-in construction failures. `layer` also preserves supplied service Layers' errors. */
-export type NodeDurableRuntimeInitializationError =
+export type NodeDurableAgentRuntimeInitializationError =
   | NodePlatformConfigError
   | SqliteStorageInitializationError;
 
-/** The services `NodeDurableRuntime.layer` provides. */
-export type NodeDurableRuntimeServices =
+/** The services `NodeDurableAgentRuntime.layer` provides. */
+export type NodeDurableAgentRuntimeServices =
   | DurableAgentRuntime
   | SubmissionLedger
   | ThreadStore
   | ScheduleStore
   | WakeScheduler
   | DurableRuntimeConfig
-  | NodeDurableRuntimeConfig;
+  | NodeDurableAgentRuntimeConfig;
 
-const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableRuntimeConfigValue);
+const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableAgentRuntimeConfigValue);
 
 const configFromOptions = (
-  options: Omit<NodeDurableRuntimeOptions, "runContext" | "toolAuthorization">,
-): Effect.Effect<NodeDurableRuntimeConfigValue, NodePlatformConfigError> =>
+  options: Omit<NodeDurableAgentRuntimeOptions, "runContext" | "toolAuthorization">,
+): Effect.Effect<NodeDurableAgentRuntimeConfigValue, NodePlatformConfigError> =>
   decodeConfigValue({
     filename: options.filename,
     deploymentId: options.deploymentId,
@@ -204,27 +213,30 @@ const configFromOptions = (
   );
 
 /** SQLite storage configuration derived from the single validated Node configuration. */
-const sqliteStorageConfigLayer: Layer.Layer<SqliteStorageConfig, never, NodeDurableRuntimeConfig> =
-  Layer.effect(SqliteStorageConfig)(
-    Effect.gen(function* () {
-      const config = yield* NodeDurableRuntimeConfig;
-
-      return SqliteStorageConfigValue.make({
-        observationPollInterval: config.observationPollInterval,
-        busyTimeout: config.busyTimeout,
-        ownershipLeaseDuration: config.ownershipLeaseDuration,
-        verifyOnOpen: config.verifyOnOpen,
-      });
-    }),
-  );
+const sqliteStorageConfigLayer: Layer.Layer<
+  SqliteStorageConfig,
+  never,
+  NodeDurableAgentRuntimeConfig
+> = Layer.effect(SqliteStorageConfig)(
+  Effect.gen(function* () {
+    const config = yield* NodeDurableAgentRuntimeConfig;
+
+    return SqliteStorageConfigValue.make({
+      observationPollInterval: config.observationPollInterval,
+      busyTimeout: config.busyTimeout,
+      ownershipLeaseDuration: config.ownershipLeaseDuration,
+      verifyOnOpen: config.verifyOnOpen,
+    });
+  }),
+);
 
 /** Thread coordinator configuration derived from the single validated Node configuration. */
 const durableRuntimeConfigLayer = (
   estimateCostMicrousd: RunCostEstimator | undefined,
-): Layer.Layer<DurableRuntimeConfig, never, NodeDurableRuntimeConfig> =>
+): Layer.Layer<DurableRuntimeConfig, never, NodeDurableAgentRuntimeConfig> =>
   Layer.effect(DurableRuntimeConfig)(
     Effect.gen(function* () {
-      const config = yield* NodeDurableRuntimeConfig;
+      const config = yield* NodeDurableAgentRuntimeConfig;
 
       return DurableRuntimeConfig.make({
         deploymentId: config.deploymentId,
@@ -241,10 +253,10 @@ const durableRuntimeConfigLayer = (
 const wakeSchedulerConfigLayer: Layer.Layer<
   NodeWakeSchedulerConfig,
   never,
-  NodeDurableRuntimeConfig
+  NodeDurableAgentRuntimeConfig
 > = Layer.effect(NodeWakeSchedulerConfig)(
   Effect.gen(function* () {
-    const config = yield* NodeDurableRuntimeConfig;
+    const config = yield* NodeDurableAgentRuntimeConfig;
 
     return { scanInterval: Duration.millis(config.wakeScanInterval) };
   }),
@@ -373,7 +385,7 @@ export const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissio
  * verified during construction: an incompatible database file fails the Layer with
  * `SqliteStorageCompatibilityError` before anything is mutated (DEPLOY-008).
  */
-export class NodeDurableRuntime {
+export class NodeDurableAgentRuntime {
   /** Validated configuration Layer; fails typed when the supplied options are out of bounds. */
   static configLayer<
     ContextError = never,
@@ -381,14 +393,14 @@ export class NodeDurableRuntime {
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
-  ): Layer.Layer<NodeDurableRuntimeConfig, NodePlatformConfigError> {
-    return Layer.effect(NodeDurableRuntimeConfig)(configFromOptions(options));
+  ): Layer.Layer<NodeDurableAgentRuntimeConfig, NodePlatformConfigError> {
+    return Layer.effect(NodeDurableAgentRuntimeConfig)(configFromOptions(options));
   }
 
   /** The full DN runtime stack over one SQLite file. */
@@ -398,20 +410,82 @@ export class NodeDurableRuntime {
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
   ): Layer.Layer<
-    NodeDurableRuntimeServices,
-    NodeDurableRuntimeInitializationError | ContextError | AuthorizationError,
+    NodeDurableAgentRuntimeServices,
+    NodeDurableAgentRuntimeInitializationError | ContextError | AuthorizationError,
     Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>
   > {
-    return Layer.unwrap(
+    return NodeDurableAgentRuntime.assemble(DurableAgentRuntime.layerWithServices, options);
+  }
+
+  /** Own typed executable registrations for every worker using this Node runtime. */
+  static layerRegistered<
+    const Entries extends ReadonlyArray<AgentRegistration>,
+    ContextError = never,
+    ContextRequirements = never,
+    AuthorizationError = never,
+    AuthorizationRequirements = never,
+  >(
+    registrations: Entries,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    return NodeDurableAgentRuntime.assemble(
+      DurableAgentRuntime.layerRegistered(registrations),
+      options,
+    );
+  }
+
+  /** Construct from registrations already resolved within the enclosing application Scope. */
+  static layerWithBindings<
+    ContextError = never,
+    ContextRequirements = never,
+    AuthorizationError = never,
+    AuthorizationRequirements = never,
+  >(
+    bindings: ReadonlyArray<ResolvedBinding>,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    return NodeDurableAgentRuntime.assemble(
+      DurableAgentRuntime.layerWithBindings(bindings),
+      options,
+    );
+  }
+
+  private static assemble<
+    RuntimeError,
+    RuntimeRequirements,
+    ContextError,
+    ContextRequirements,
+    AuthorizationError,
+    AuthorizationRequirements,
+  >(
+    runtimeLayer: Layer.Layer<DurableAgentRuntime, RuntimeError, RuntimeRequirements>,
+    options: NodeDurableAgentRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
+  ) {
+    const assembled = Layer.unwrap(
       Effect.map(configFromOptions(options), (config) => {
-        const nodeConfigLayer = Layer.succeed(NodeDurableRuntimeConfig)(config);
+        const nodeConfigLayer = Layer.succeed(NodeDurableAgentRuntimeConfig)(config);
 
         const infrastructure = Layer.mergeAll(
           sqliteStorageConfigLayer,
@@ -443,7 +517,7 @@ export class NodeDurableRuntime {
           ),
         );
 
-        return DurableAgentRuntime.layerWithServices.pipe(
+        return runtimeLayer.pipe(
           Layer.provideMerge(
             Layer.mergeAll(ports, durableRuntimeConfigLayer(options.estimateCostMicrousd)),
           ),
@@ -466,5 +540,13 @@ export class NodeDurableRuntime {
         );
       }),
     );
+
+    const runtime: Layer.Layer<
+      NodeDurableAgentRuntimeServices,
+      Layer.Error<typeof assembled>,
+      Layer.Services<typeof assembled>
+    > = assembled;
+
+    return runtime;
   }
 }

package/src/{host.ts → NodeDurableHost.ts}

@@ -1,17 +1,20 @@
-import type { ThreadId, SubmissionId } from "@effect-agent/core";
+import { type ThreadId, type SubmissionId } from "@effect-agent/core/Identifiers";
+import {
+  type IntegrityReport,
+  type ObligationReport,
+  type ObligationThresholds,
+  type RecoveryExplanation,
+  type RetryCommand,
+} from "@effect-agent/thread/Admin";
 import {
-  compileRegistrations,
   type AgentRegistration,
+  type ResolvedBinding,
+  type DurableBindingFailure,
+} from "@effect-agent/thread/AgentRegistration";
+import {
   DurableAgentRuntime,
-  type AbortCommand,
-  type AbortIntent,
-  type CanonicalRecordEnvelope,
-  type ThreadNotMaterialized,
-  type ThreadStoreError,
   type DurableAbortFailure,
   type DurableAwaitFailure,
-  type ResolvedBinding,
-  type DurableBindingFailure,
   type DurableExplainFailure,
   type DurableObserveOptions,
   type DurableObligationFailure,
@@ -21,26 +24,29 @@ import {
   type DurableSubmitOptions,
   type DurableVerifyFailure,
   type DurableWorkerFailure,
-  type IntegrityReport,
-  type ObligationReport,
-  type ObligationThresholds,
-  type OperationDenied,
   type Receipt,
-  type RecoveryExplanation,
   type RecoveryReport,
-  type RetryCommand,
+} from "@effect-agent/thread/DurableAgentRuntime";
+import { type OperationDenied } from "@effect-agent/thread/OperationAuthorizer";
+import { type CanonicalRecordEnvelope } from "@effect-agent/thread/Records";
+import {
+  type AbortCommand,
+  type AbortIntent,
   type Settlement,
-} from "@effect-agent/thread";
-import { NodeCrypto } from "@effect/platform-node";
+} from "@effect-agent/thread/SubmissionLedger";
+import {
+  type ThreadNotMaterialized,
+  type ThreadStoreError,
+} from "@effect-agent/thread/ThreadStore";
 import { type Stream, Context, type Crypto, Effect, Layer, Ref, Schema } from "effect";
 
 import {
-  NodeDurableRuntime,
-  NodeDurableRuntimeConfig,
-  type NodeDurableRuntimeInitializationError,
-  type NodeDurableRuntimeOptions,
-  type NodeDurableRuntimeServices,
-} from "./layers.ts";
+  NodeDurableAgentRuntime,
+  NodeDurableAgentRuntimeConfig,
+  type NodeDurableAgentRuntimeInitializationError,
+  type NodeDurableAgentRuntimeOptions,
+  type NodeDurableAgentRuntimeServices,
+} from "./NodeDurableAgentRuntime.ts";
 
 /**
  * Admission is not open on this host: it is shutting down (deployment §6 step 1, DEPLOY-005).
@@ -50,75 +56,74 @@ export class AdmissionClosed extends Schema.TaggedError<AdmissionClosed>()("Admi
   message: Schema.String,
 }) {}
 
-const makeHost = (bindings: ReadonlyArray<ResolvedBinding>) =>
-  Effect.gen(function* () {
-    const runtime = yield* DurableAgentRuntime;
-    const config = yield* NodeDurableRuntimeConfig;
+const makeHost = Effect.gen(function* () {
+  const runtime = yield* DurableAgentRuntime;
+  const config = yield* NodeDurableAgentRuntimeConfig;
 
-    // Startup gate (deployment §5, plan §host): configuration decoding and storage compatibility
-    // already gated this Layer's dependencies; the last gate before admission opens is recovering
-    // EVERY nonterminal Submission. Work needing a live Agent Binding is reported `deferred` and
-    // stays a visible obligation for `runWorkers`; lanes durably blocked on an Unknown Outcome are
-    // reported `unknown` and wait for the authorized `resolveUnknown` path (DUR-017) — they consume
-    // no worker permit while the settlement obligation stays owed.
-    const startupRecovery = yield* runtime.runRecovery;
+  // Startup gate (deployment §5, plan §host): configuration decoding and storage compatibility
+  // already gated this Layer's dependencies; the last gate before admission opens is recovering
+  // EVERY nonterminal Submission. Work needing a live Agent Binding is reported `deferred` and
+  // stays a visible obligation for `runWorkers`; lanes durably blocked on an Unknown Outcome are
+  // reported `unknown` and wait for the authorized `resolveUnknown` path (DUR-017) — they consume
+  // no worker permit while the settlement obligation stays owed.
+  const startupRecovery = yield* runtime.runRecovery;
 
-    const admission = yield* Ref.make(true);
+  const admission = yield* Ref.make(true);
 
-    // Shutdown step 1 (DEPLOY-005): admission closes before the ownership drain in the runtime
-    // Layer below releases claims and before the stores close in reverse acquisition order.
-    yield* Effect.addFinalizer(() => Ref.set(admission, false));
+  // Shutdown step 1 (DEPLOY-005): admission closes before the ownership drain in the runtime
+  // Layer below releases claims and before the stores close in reverse acquisition order.
+  yield* Effect.addFinalizer(() => Ref.set(admission, false));
 
-    const requireAdmission: Effect.Effect<void, AdmissionClosed> = Ref.get(admission).pipe(
-      Effect.flatMap((open) =>
-        open
-          ? Effect.void
-          : Effect.fail(
-              AdmissionClosed.make({ message: "The host is shutting down; admission is closed." }),
-            ),
-      ),
-    );
+  const requireAdmission: Effect.Effect<void, AdmissionClosed> = Ref.get(admission).pipe(
+    Effect.flatMap((open) =>
+      open
+        ? Effect.void
+        : Effect.fail(
+            AdmissionClosed.make({ message: "The host is shutting down; admission is closed." }),
+          ),
+    ),
+  );
 
-    const submit = <InputSchema extends Schema.Top>(
-      agent: DurableSubmitAgent<InputSchema>,
-      input: InputSchema["Type"],
-      options: DurableSubmitOptions,
-    ): Effect.Effect<
-      Receipt,
-      AdmissionClosed | DurableSubmitFailure,
-      InputSchema["EncodingServices"]
-    > => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
+  const submit = <InputSchema extends Schema.Top>(
+    agent: DurableSubmitAgent<InputSchema>,
+    input: InputSchema["Type"],
+    options: DurableSubmitOptions,
+  ): Effect.Effect<
+    Receipt,
+    AdmissionClosed | DurableSubmitFailure,
+    InputSchema["EncodingServices"]
+  > => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
 
-    const runWorkers = <A, E, R>(worker: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> =>
-      Effect.forEach(
-        Array.from({ length: config.workerConcurrency }, (_, index) => index),
-        () => worker,
-        { concurrency: "unbounded", discard: true },
-      );
+  const runWorkers = <A, E, R>(worker: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> =>
+    Effect.forEach(
+      Array.from({ length: config.workerConcurrency }, (_, index) => index),
+      () => worker,
+      { concurrency: "unbounded", discard: true },
+    );
 
-    // S2 multi-binding pool: every claimed head resolves its exact registered Binding through
-    // the host's exact registrations, so one bounded
-    // pool serves parent and child lanes — the spec §12 smallest-pool suspension/wakeup proof
-    // runs `workerConcurrency: 1` over exactly this loop.
-    const runResolvedWorkers = runWorkers(runtime.runResolvedWorker(bindings));
+  // S2 multi-binding pool: every claimed head resolves its exact registered Binding through
+  // the host's exact registrations, so one bounded
+  // pool serves parent and child lanes — the spec §12 smallest-pool suspension/wakeup proof
+  // runs `workerConcurrency: 1` over exactly this loop.
+  const runResolvedWorkers = runWorkers(runtime.runResolvedWorker);
 
-    return NodeDurableHost.of({
-      startupRecovery,
-      admissionOpen: Ref.get(admission),
-      submit,
-      awaitSettlement: runtime.awaitSettlement,
-      observe: runtime.observe,
-      abort: runtime.abort,
-      explain: runtime.explain,
-      explainThread: runtime.explainThread,
-      verify: runtime.verify,
-      retry: runtime.retry,
-      wake: runtime.wake,
-      scanObligations: runtime.scanObligations,
-      runWorkers,
-      runResolvedWorkers,
-    });
+  return NodeDurableHost.of({
+    startupRecovery,
+    admissionOpen: Ref.get(admission),
+    submit,
+    awaitSettlement: runtime.awaitSettlement,
+    observe: runtime.observe,
+    abort: runtime.abort,
+    explain: runtime.explain,
+    explainThread: runtime.explainThread,
+    verify: runtime.verify,
+    retry: runtime.retry,
+    wake: runtime.wake,
+    scanObligations: runtime.scanObligations,
+    runWorkers,
+    runResolvedWorkers,
   });
+});
 
 /**
  * Operational host lifecycle for the DN runtime (deployment §2/§5/§6).
@@ -210,57 +215,53 @@ export class NodeDurableHost extends Context.Service<
     AuthorizationRequirements = never,
   >(
     registrations: Entries,
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     >,
   ) {
-    return Layer.unwrap(
-      Effect.map(compileRegistrations(registrations), (bindings) =>
-        NodeDurableHost.layerStack({ ...options, bindings }),
-      ),
-    ).pipe(Layer.provide(NodeCrypto.layer));
+    return NodeDurableHost.layer.pipe(
+      Layer.provideMerge(NodeDurableAgentRuntime.layerRegistered(registrations, options)),
+    );
   }
 
   /**
-   * Host gates over an assembled `NodeDurableRuntime` stack. Bindings must carry the exact
-   * digests stored by submitters. Omission registers no Agents, so resolved work fails closed.
+   * Host gates over an assembled `NodeDurableAgentRuntime` stack. The runtime Layer owns
+   * executable registrations; omission registers no Agents, so resolved work fails closed.
    */
-  static readonly layer = (
-    bindings: ReadonlyArray<ResolvedBinding> = [],
-  ): Layer.Layer<
+  static readonly layer: Layer.Layer<
     NodeDurableHost,
     DurableWorkerFailure,
-    DurableAgentRuntime | NodeDurableRuntimeConfig
-  > => Layer.effect(NodeDurableHost)(makeHost(bindings));
+    DurableAgentRuntime | NodeDurableAgentRuntimeConfig
+  > = Layer.effect(NodeDurableHost)(makeHost);
 
-  /** The complete DN host: `NodeDurableRuntime.layer(options)` plus the host lifecycle gates. */
+  /** The complete DN host: `NodeDurableAgentRuntime.layer(options)` plus the host lifecycle gates. */
   static layerStack<
     ContextError = never,
     ContextRequirements = never,
     AuthorizationError = never,
     AuthorizationRequirements = never,
   >(
-    options: NodeDurableRuntimeOptions<
+    options: NodeDurableAgentRuntimeOptions<
       ContextError,
       ContextRequirements,
       AuthorizationError,
       AuthorizationRequirements
     > & { readonly bindings?: ReadonlyArray<ResolvedBinding> },
   ): Layer.Layer<
-    NodeDurableHost | NodeDurableRuntimeServices,
+    NodeDurableHost | NodeDurableAgentRuntimeServices,
     | DurableWorkerFailure
-    | NodeDurableRuntimeInitializationError
+    | NodeDurableAgentRuntimeInitializationError
     | ContextError
     | AuthorizationError,
     Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>
   > {
     const { bindings = [], ...runtimeOptions } = options;
 
-    return NodeDurableHost.layer(bindings).pipe(
-      Layer.provideMerge(NodeDurableRuntime.layer(runtimeOptions)),
+    return NodeDurableHost.layer.pipe(
+      Layer.provideMerge(NodeDurableAgentRuntime.layerWithBindings(bindings, runtimeOptions)),
     );
   }
 }

package/src/{scheduling.ts → NodeScheduling.ts}

@@ -1,20 +1,22 @@
 import {
-  type ScheduleProcessFailure,
   type ScheduleAuthorizer,
   type SchedulingLimits,
   ScheduleStorageError,
   ScheduleStore,
   type ScheduleValidationError,
   ScheduleWake,
+  defaultSchedulingLimits,
+} from "@effect-agent/thread/Schedule";
+import {
+  type ScheduleProcessFailure,
   Scheduling,
   ScheduleDriver,
-  defaultSchedulingLimits,
-} from "@effect-agent/thread";
+} from "@effect-agent/thread/Scheduling";
 import { NodeCrypto } from "@effect/platform-node";
 import { Cause, Duration, Effect, Layer, Option, PubSub, Result } from "effect";
 
-import type { NodeDurableHost } from "./host.ts";
-import { nodeScheduledInputAdmissionLayer } from "./subscriptions.ts";
+import type { NodeDurableHost } from "./NodeDurableHost.ts";
+import { nodeScheduledInputAdmissionLayer } from "./NodeSubscriptions.ts";
 
 /** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
 export const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake> = Layer.effect(