@effect-agent/platform-node 0.1.0-beta.38 → 0.1.0-beta.40

package/dist/index.d.mts

@@ -1,8 +1,8 @@
-import { AbortCommand, AbortIntent, AgentBindingResolver, CanonicalRecordEnvelope, ConversationNotMaterialized, ConversationStore, ConversationStoreError, DurableAbortFailure, DurableAgentRuntime, DurableAwaitFailure, DurableBindingFailure, DurableExplainFailure, DurableObligationFailure, DurableObserveOptions, DurableRetryFailure, DurableRuntimeConfig, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitFailure, DurableSubmitOptions, DurableVerifyFailure, DurableWorkerFailure, IntegrityReport, ObligationReport, ObligationThresholds, OperationDenied, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, ScheduleAuthorizer, ScheduleStore, ScheduleValidationError, ScheduleWake, ScheduledInputAdmission, Scheduling, SchedulingLimits, Settlement, SubmissionLedger, ToolReconciler, WakeScheduler } from "@effect-agent/session";
-import { Context, Duration, Effect, Layer, Schema, Stream } from "effect";
-import { RunCostEstimator, RunToolFailureObserver } from "@effect-agent/engine";
+import { AbortCommand, AbortIntent, AgentRegistration, CanonicalRecordEnvelope, DurableAbortFailure, DurableAgentRuntime, DurableAwaitFailure, DurableBindingFailure, DurableExplainFailure, DurableObligationFailure, DurableObserveOptions, DurableRetryFailure, DurableRuntimeConfig, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitFailure, DurableSubmitOptions, DurableVerifyFailure, DurableWorkerFailure, EventSources, IntegrityReport, ObligationReport, ObligationThresholds, OperationDenied, PreparedInputAdmission, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, ScheduleAuthorizer, ScheduleStore, ScheduleValidationError, ScheduleWake, ScheduledInputAdmission, Scheduling, SchedulingLimits, Settlement, SubmissionLedger, SubscriptionAuthorizer, SubscriptionError, SubscriptionInputBindings, SubscriptionIntake, SubscriptionLimits, SubscriptionStore, Subscriptions, ThreadNotMaterialized, ThreadStore, ThreadStoreError, ToolReconciler, WakeScheduler } from "@effect-agent/thread";
+import { Context, Crypto, Duration, Effect, Layer, Schema, Stream } from "effect";
+import { RunContextPreparation, RunCostEstimator, RunToolAuthorization, RunToolFailureObserver } from "@effect-agent/engine";
 import { SqliteStorageFailpointHandler, SqliteStorageInitializationError } from "@effect-agent/storage-sqlite";
-import { ConversationId, SubmissionId } from "@effect-agent/core";
+import { SubmissionId, ThreadId } from "@effect-agent/core";
 //#region src/layers.d.ts
 declare const NodePlatformConfigError_base: Schema.Class<NodePlatformConfigError, Schema.TaggedStruct<"NodePlatformConfigError", {
   readonly message: Schema.String;
@@ -11,10 +11,10 @@ declare const NodePlatformConfigError_base: Schema.Class<NodePlatformConfigError
 /** The supplied Node durable runtime configuration failed schema validation (DEPLOY-003). */
 declare class NodePlatformConfigError extends NodePlatformConfigError_base {}
 declare const NodeDurableRuntimeConfigValue_base: Schema.Class<NodeDurableRuntimeConfigValue, Schema.Struct<{
-  /** SQLite database file backing BOTH the Conversation Log and the Submission Ledger. */
+  /** SQLite database file backing BOTH the Thread Log and the Submission Ledger. */
   readonly filename: Schema.NonEmptyString;
-  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/session/DeploymentId">;
-  readonly producerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/session/ProducerId">;
+  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  readonly producerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
   /** Submission ownership lease duration (D5); liveness hint only, epochs stay authoritative. */
   readonly ownershipLeaseDuration: Schema.Int;
   /** Finite bound on concurrent worker loops per host (rule 10). */
@@ -48,7 +48,7 @@ declare class NodeDurableRuntimeConfig extends NodeDurableRuntimeConfig_base {}
  * to the documented production values; everything is schema-decoded into
  * `NodeDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
  */
-interface NodeDurableRuntimeOptions {
+interface NodeDurableRuntimeOptions<ContextError = never, ContextRequirements = never, AuthorizationError = never, AuthorizationRequirements = never> {
   readonly filename: string;
   readonly deploymentId: string;
   readonly producerId: string;
@@ -85,20 +85,19 @@ interface NodeDurableRuntimeOptions {
    * DUR-017 resolution path.
    */
   readonly toolReconciler?: Layer.Layer<ToolReconciler> | undefined;
+  /** Host prompt preparation/compaction, acquired once with the runtime; default pass-through. */
+  readonly runContext?: Layer.Layer<RunContextPreparation, ContextError, ContextRequirements | Crypto.Crypto> | undefined;
   /**
-   * Registered worker Bindings resolved at durable claim time:
-   * build each with `DurableWorkerBinding.make(binding, digests)` so
-   * `NodeDurableHost.runResolvedWorkers` / `DurableAgentRuntime.runResolvedWorker` can serve
-   * parent and child lanes from one pool with exact-digest resolution (SUB-023). Defaults to
-   * the empty registration: every resolved claim then fails closed (`BindingUnavailable` for a
-   * root, the framework `ChildCompatibilityFailure` Settlement for a parent-linked child).
+   * Independent action-time Tool authority, acquired once with the runtime; default allow-all.
+   * Construction errors and application dependencies remain in the assembled Layer's E and R.
+   * The platform supplies Crypto to both extension Layers.
    */
-  readonly bindings?: ReadonlyArray<ResolvedBinding> | undefined;
+  readonly toolAuthorization?: Layer.Layer<RunToolAuthorization, AuthorizationError, AuthorizationRequirements | Crypto.Crypto> | undefined;
 }
-/** Every construction failure of the assembled Node durable runtime stack. */
+/** Built-in construction failures. `layer` also preserves supplied service Layers' errors. */
 type NodeDurableRuntimeInitializationError = NodePlatformConfigError | SqliteStorageInitializationError;
 /** The services `NodeDurableRuntime.layer` provides. */
-type NodeDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ConversationStore | ScheduleStore | WakeScheduler | DurableRuntimeConfig | NodeDurableRuntimeConfig | AgentBindingResolver;
+type NodeDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ThreadStore | ScheduleStore | WakeScheduler | DurableRuntimeConfig | NodeDurableRuntimeConfig;
 /**
  * Shutdown-drain decorator for a `SubmissionLedger` (deployment §6 step 6): every ownership
  * period granted through this Layer is tracked — claims start tracking, renewals follow token
@@ -111,7 +110,7 @@ declare const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissi
 /**
  * The DN Layer assembly (deployment §12: a Layer-assembly library, not an app entrypoint).
  * `layer(options)` decodes the configuration, opens ONE SQLite database serving both the
- * Conversation Log and the Submission Ledger (so claims fence the same producer epochs), wires
+ * Thread Log and the Submission Ledger (so claims fence the same producer epochs), wires
  * the Node wake scheduler with its ledger-scan fallback, wraps the ledger with the shutdown
  * ownership drain, defaults the Tool reconciliation policy to the fail-closed
  * `ToolReconciler.uncertain` (override via `options.toolReconciler`), and provides a ready
@@ -121,9 +120,9 @@ declare const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissi
  */
 declare class NodeDurableRuntime {
   /** Validated configuration Layer; fails typed when the supplied options are out of bounds. */
-  static configLayer(options: NodeDurableRuntimeOptions): Layer.Layer<NodeDurableRuntimeConfig, NodePlatformConfigError>;
+  static configLayer<ContextError = never, ContextRequirements = never, AuthorizationError = never, AuthorizationRequirements = never>(options: NodeDurableRuntimeOptions<ContextError, ContextRequirements, AuthorizationError, AuthorizationRequirements>): Layer.Layer<NodeDurableRuntimeConfig, NodePlatformConfigError>;
   /** The full DN runtime stack over one SQLite file. */
-  static layer(options: NodeDurableRuntimeOptions): Layer.Layer<NodeDurableRuntimeServices, NodeDurableRuntimeInitializationError>;
+  static layer<ContextError = never, ContextRequirements = never, AuthorizationError = never, AuthorizationRequirements = never>(options: NodeDurableRuntimeOptions<ContextError, ContextRequirements, AuthorizationError, AuthorizationRequirements>): Layer.Layer<NodeDurableRuntimeServices, NodeDurableRuntimeInitializationError | ContextError | AuthorizationError, Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>>;
 }
 //#endregion
 //#region src/host.d.ts
@@ -147,18 +146,18 @@ declare const NodeDurableHost_base: Context.ServiceClass<NodeDurableHost, "@effe
   /** `DurableAgentRuntime.submit` behind the host admission gate. */
   readonly submit: <InputSchema extends Schema.Top>(agent: DurableSubmitAgent<InputSchema>, input: InputSchema["Type"], options: DurableSubmitOptions) => Effect.Effect<Receipt, AdmissionClosed | DurableSubmitFailure, InputSchema["EncodingServices"]>;
   readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, DurableAwaitFailure>;
-  readonly observe: (receipt: Receipt, options?: DurableObserveOptions) => Stream.Stream<CanonicalRecordEnvelope, ConversationStoreError | ConversationNotMaterialized | OperationDenied>;
+  readonly observe: (receipt: Receipt, options?: DurableObserveOptions) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized | OperationDenied>;
   readonly abort: (command: AbortCommand) => Effect.Effect<AbortIntent, DurableAbortFailure>;
   /** `DurableAgentRuntime.explain` — read-only recovery explanation of one Submission (P7). */
   readonly explain: (submissionId: SubmissionId) => Effect.Effect<RecoveryExplanation, DurableExplainFailure>;
-  /** `DurableAgentRuntime.explainConversation` — explain every nonterminal lane member. */
-  readonly explainConversation: (conversationId: ConversationId) => Effect.Effect<ReadonlyArray<RecoveryExplanation>, DurableExplainFailure>;
+  /** `DurableAgentRuntime.explainThread` — explain every nonterminal lane member. */
+  readonly explainThread: (threadId: ThreadId) => Effect.Effect<ReadonlyArray<RecoveryExplanation>, DurableExplainFailure>;
   /** `DurableAgentRuntime.verify` — read-only integrity checks, never a repair (P7). */
-  readonly verify: (conversationId: ConversationId) => Effect.Effect<IntegrityReport, DurableVerifyFailure>;
+  readonly verify: (threadId: ThreadId) => Effect.Effect<IntegrityReport, DurableVerifyFailure>;
   /** `DurableAgentRuntime.retry` — audited single-Submission re-drive with typed refusals. */
   readonly retry: (command: RetryCommand) => Effect.Effect<RecoveryReport, DurableRetryFailure>;
   /** `DurableAgentRuntime.wake` — the documented operator liveness nudge for one lane. */
-  readonly wake: (conversationId: ConversationId) => Effect.Effect<void, OperationDenied>;
+  readonly wake: (threadId: ThreadId) => Effect.Effect<void, OperationDenied>;
   /** `DurableAgentRuntime.scanObligations` — the scan-based DUR-017/OPS-001 report. */
   readonly scanObligations: (thresholds: ObligationThresholds) => Effect.Effect<ObligationReport, DurableObligationFailure>;
   /**
@@ -189,18 +188,25 @@ declare const NodeDurableHost_base: Context.ServiceClass<NodeDurableHost, "@effe
  * shutdown, provides correctness (DEPLOY-006).
  */
 declare class NodeDurableHost extends NodeDurableHost_base {
-  /** Host gates over an already-assembled `NodeDurableRuntime` stack. */
-  static readonly layer: Layer.Layer<NodeDurableHost, DurableWorkerFailure, DurableAgentRuntime | NodeDurableRuntimeConfig | AgentBindingResolver>;
+  /**
+   * Compile typed registrations and acquire the complete host in one Layer Scope.
+   * Node supplies Crypto; model, tool, instruction, and schema services remain required.
+   * Startup recovery and shutdown gates are unchanged. Workers start only when the caller
+   * runs runResolvedWorkers; this constructor never starts a background worker.
+   */
+  static layerRegistered<const Entries extends ReadonlyArray<AgentRegistration>, ContextError = never, ContextRequirements = never, AuthorizationError = never, AuthorizationRequirements = never>(registrations: Entries, options: NodeDurableRuntimeOptions<ContextError, ContextRequirements, AuthorizationError, AuthorizationRequirements>): Layer.Layer<NodeDurableHost | NodeDurableRuntimeServices, AuthorizationError | ContextError | DurableWorkerFailure | NodeDurableRuntimeInitializationError, Exclude<Exclude<AuthorizationRequirements, Crypto.Crypto>, Crypto.Crypto> | Exclude<Exclude<ContextRequirements, Crypto.Crypto>, Crypto.Crypto> | Exclude<Exclude<[Entries[number]] extends [never] ? never : Entries[number] extends (infer T_1) ? T_1 extends Entries[number] ? T_1 extends AgentRegistration<infer A extends import("@effect-agent/thread").ExecutableAgentBinding> ? import("@effect-agent/thread").DurableWorkerRequirements<A> : never : never : never, import("effect/Scope").Scope>, Crypto.Crypto>>;
+  /**
+   * 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.
+   */
+  static readonly layer: (bindings?: ReadonlyArray<ResolvedBinding>) => Layer.Layer<NodeDurableHost, DurableWorkerFailure, DurableAgentRuntime | NodeDurableRuntimeConfig>;
   /** The complete DN host: `NodeDurableRuntime.layer(options)` plus the host lifecycle gates. */
-  static layerStack(options: NodeDurableRuntimeOptions): Layer.Layer<NodeDurableHost | NodeDurableRuntimeServices, DurableWorkerFailure | NodeDurableRuntimeInitializationError>;
+  static layerStack<ContextError = never, ContextRequirements = never, AuthorizationError = never, AuthorizationRequirements = never>(options: NodeDurableRuntimeOptions<ContextError, ContextRequirements, AuthorizationError, AuthorizationRequirements> & {
+    readonly bindings?: ReadonlyArray<ResolvedBinding>;
+  }): Layer.Layer<NodeDurableHost | NodeDurableRuntimeServices, DurableWorkerFailure | NodeDurableRuntimeInitializationError | ContextError | AuthorizationError, Exclude<ContextRequirements | AuthorizationRequirements, Crypto.Crypto>>;
 }
 //#endregion
 //#region src/scheduling.d.ts
-/**
- * Scheduled admission through the existing host gate. Once the gate admits the call, every
- * runtime failure stays ambiguous because the Submission may already have committed.
- */
-declare const nodeScheduledInputAdmissionLayer: Layer.Layer<ScheduledInputAdmission, never, NodeDurableHost>;
 /** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
 declare const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake>;
 interface NodeSchedulingOptions {
@@ -214,9 +220,24 @@ declare class NodeScheduling {
   static layer(options?: NodeSchedulingOptions): Layer.Layer<Scheduling, ScheduleValidationError, NodeDurableHost | ScheduleStore | ScheduleAuthorizer>;
 }
 //#endregion
+//#region src/subscriptions.d.ts
+/** Ordinary prepared admission through the Scope-owned Node host gate. */
+declare const nodePreparedInputAdmissionLayer: Layer.Layer<PreparedInputAdmission, never, NodeDurableHost>;
+declare const nodeScheduledInputAdmissionLayer: Layer.Layer<ScheduledInputAdmission, never, NodeDurableHost>;
+interface NodeSubscriptionsOptions {
+  readonly limits?: SubscriptionLimits | undefined;
+}
+/**
+ * One Scope-owned subscription partition in the sole process owning its SQLite database.
+ * Indexed polling repairs restart and lost wake state; closing the Scope interrupts the driver.
+ */
+declare class NodeSubscriptions {
+  static layer(options?: NodeSubscriptionsOptions): Layer.Layer<Subscriptions | SubscriptionIntake, SubscriptionError, NodeDurableHost | SubscriptionStore | SubscriptionAuthorizer | EventSources | SubscriptionInputBindings>;
+}
+//#endregion
 //#region src/wake-scheduler.d.ts
 declare const NodeWakeSchedulerConfig_base: Context.ServiceClass<NodeWakeSchedulerConfig, "@effect-agent/platform-node/NodeWakeSchedulerConfig", {
-  /** Interval between ledger scans that re-emit every nonterminal Conversation lane. */
+  /** Interval between ledger scans that re-emit every nonterminal Thread lane. */
   readonly scanInterval: Duration.Duration;
 }>;
 /** Cadence authority for the Node wake scheduler's ledger-scan fallback loop. */
@@ -234,5 +255,5 @@ declare class NodeWakeSchedulerConfig extends NodeWakeSchedulerConfig_base {
  */
 declare const nodeWakeSchedulerLayer: Layer.Layer<WakeScheduler, never, SubmissionLedger | NodeWakeSchedulerConfig>;
 //#endregion
-export { AdmissionClosed, NodeDurableHost, NodeDurableRuntime, NodeDurableRuntimeConfig, NodeDurableRuntimeConfigValue, NodeDurableRuntimeInitializationError, NodeDurableRuntimeOptions, NodeDurableRuntimeServices, NodePlatformConfigError, NodeScheduling, NodeSchedulingOptions, NodeWakeSchedulerConfig, nodeScheduleWakeLayer, nodeScheduledInputAdmissionLayer, nodeWakeSchedulerLayer, ownershipDrainLayer };
+export { AdmissionClosed, NodeDurableHost, NodeDurableRuntime, NodeDurableRuntimeConfig, NodeDurableRuntimeConfigValue, NodeDurableRuntimeInitializationError, NodeDurableRuntimeOptions, NodeDurableRuntimeServices, NodePlatformConfigError, NodeScheduling, NodeSchedulingOptions, NodeSubscriptions, NodeSubscriptionsOptions, NodeWakeSchedulerConfig, nodePreparedInputAdmissionLayer, nodeScheduleWakeLayer, nodeScheduledInputAdmissionLayer, nodeWakeSchedulerLayer, ownershipDrainLayer };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { AgentBindingResolver, DEFAULT_OWNERSHIP_LEASE_DURATION, DeploymentId, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, PersistedJson, ProducerId, ReleaseOwnershipRequest, ScheduleDriver, ScheduleStorageError, ScheduleStore, ScheduleWake, ScheduledInputAdmission, ScheduledInputRetryable, Scheduling, SubmissionLedger, ToolReconciler, WakeScheduler, defaultSchedulingLimits, makeWakeSubscriptionHub } from "@effect-agent/session";
-import { Cause, Context, Duration, Effect, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
-import { CurrentToolFailureObserver, toolFailureObserverLayer } from "@effect-agent/engine";
-import { SqliteStorageConfig, SqliteStorageConfigValue, conversationStoreLayer, scheduleStoreLayer, storageFailpointLayer, submissionLedgerLayer } from "@effect-agent/storage-sqlite";
+import { DEFAULT_OWNERSHIP_LEASE_DURATION, DeploymentId, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, PersistedJson, PreparedInputAdmission, ProducerId, ReleaseOwnershipRequest, ScheduleDriver, ScheduleStorageError, ScheduleStore, ScheduleWake, ScheduledInputAdmission, ScheduledInputRetryable, Scheduling, SubmissionLedger, SubscriptionDriver, SubscriptionIntake, SubscriptionStore, Subscriptions, ToolReconciler, WakeScheduler, compileRegistrations, defaultSchedulingLimits, defaultSubscriptionLimits, makeWakeSubscriptionHub } from "@effect-agent/thread";
 import { NodeCrypto } from "@effect/platform-node";
+import { Cause, Context, Duration, Effect, Exit, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
+import { CurrentToolFailureObserver, RunContextPreparationPassthrough, RunToolAuthorization, toolFailureObserverLayer } from "@effect-agent/engine";
+import { SqliteStorageConfig, SqliteStorageConfigValue, scheduleStoreLayer, storageFailpointLayer, submissionLedgerLayer, threadStoreLayer } from "@effect-agent/storage-sqlite";
 import { SqliteClient } from "@effect/sql-sqlite-node";
 //#region src/wake-scheduler.ts
 /**
@@ -23,13 +23,13 @@ const makeWakeScheduler = Effect.gen(function* () {
 	const progress = yield* makeWakeSubscriptionHub;
 	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
 	/**
-	* One fallback scan: every Conversation lane with nonterminal work, deduplicated. A scan
+	* One fallback scan: every Thread lane with nonterminal work, deduplicated. A scan
 	* failure degrades to "no hints this round" — the wake channel has no error contract and the
 	* next round retries — but is logged so a persistently failing ledger stays visible.
 	*/
 	const scanOnce = Stream.runCollect(ledger.scanNonterminal).pipe(Effect.map((snapshots) => {
 		const lanes = /* @__PURE__ */ new Set();
-		for (const snapshot of snapshots) lanes.add(snapshot.conversationId);
+		for (const snapshot of snapshots) lanes.add(snapshot.threadId);
 		return [...lanes];
 	}), Effect.catch((error) => Effect.logWarning("NodeWakeScheduler fallback scan failed", error).pipe(Effect.as([]))));
 	/**
@@ -39,7 +39,7 @@ const makeWakeScheduler = Effect.gen(function* () {
 	*/
 	const fallbackScans = Stream.fromIterableEffectRepeat(Effect.sleep(config.scanInterval).pipe(Effect.andThen(scanOnce)));
 	return WakeScheduler.of({
-		notify: (conversationId) => progress.notify(conversationId).pipe(Effect.andThen(PubSub.publish(hints, conversationId)), Effect.asVoid),
+		notify: (threadId) => progress.notify(threadId).pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.asVoid),
 		subscribe: progress.subscribe,
 		wakes: Stream.merge(Stream.fromPubSub(hints), fallbackScans)
 	});
@@ -68,7 +68,7 @@ var NodePlatformConfigError = class extends Schema.TaggedError()("NodePlatformCo
 * finite; `workerConcurrency` caps how many worker loops `NodeDurableHost.runWorkers` drives.
 */
 var NodeDurableRuntimeConfigValue = class extends Schema.Class("@effect-agent/platform-node/NodeDurableRuntimeConfigValue")({
-	/** SQLite database file backing BOTH the Conversation Log and the Submission Ledger. */
+	/** SQLite database file backing BOTH the Thread Log and the Submission Ledger. */
 	filename: Schema.NonEmptyString,
 	deploymentId: DeploymentId,
 	producerId: ProducerId,
@@ -121,7 +121,7 @@ const sqliteStorageConfigLayer = Layer.effect(SqliteStorageConfig)(Effect.gen(fu
 		verifyOnOpen: config.verifyOnOpen
 	});
 }));
-/** Session coordinator configuration derived from the single validated Node configuration. */
+/** Thread coordinator configuration derived from the single validated Node configuration. */
 const durableRuntimeConfigLayer = (estimateCostMicrousd) => Layer.effect(DurableRuntimeConfig)(Effect.gen(function* () {
 	const config = yield* NodeDurableRuntimeConfig;
 	return DurableRuntimeConfig.make({
@@ -198,7 +198,7 @@ const ownershipDrainLayer = Layer.effect(SubmissionLedger)(Effect.gen(function*
 /**
 * The DN Layer assembly (deployment §12: a Layer-assembly library, not an app entrypoint).
 * `layer(options)` decodes the configuration, opens ONE SQLite database serving both the
-* Conversation Log and the Submission Ledger (so claims fence the same producer epochs), wires
+* Thread Log and the Submission Ledger (so claims fence the same producer epochs), wires
 * the Node wake scheduler with its ledger-scan fallback, wraps the ledger with the shutdown
 * ownership drain, defaults the Tool reconciliation policy to the fail-closed
 * `ToolReconciler.uncertain` (override via `options.toolReconciler`), and provides a ready
@@ -222,9 +222,8 @@ var NodeDurableRuntime = class {
 			const runtimeFailpointLayer = options.runtimeFailpoint === void 0 ? DurableRuntimeFailpoint.layer : Layer.succeed(DurableRuntimeFailpoint)({ hit: options.runtimeFailpoint });
 			const reconcilerLayer = options.toolReconciler ?? ToolReconciler.uncertain;
 			const observerLayer = options.toolFailureObserver === void 0 ? Layer.succeed(CurrentToolFailureObserver)(void 0) : toolFailureObserverLayer(options.toolFailureObserver);
-			const bindingResolverLayer = AgentBindingResolver.layer(options.bindings ?? []);
-			const ports = Layer.mergeAll(conversationStoreLayer, scheduleStoreLayer, nodeWakeSchedulerLayer.pipe(Layer.provideMerge(ownershipDrainLayer.pipe(Layer.provide(submissionLedgerLayer)))));
-			return DurableAgentRuntime.layer.pipe(Layer.provideMerge(Layer.mergeAll(ports, durableRuntimeConfigLayer(options.estimateCostMicrousd), bindingResolverLayer)), Layer.provide(Layer.mergeAll(wakeSchedulerConfigLayer, runtimeFailpointLayer, reconcilerLayer, observerLayer)), Layer.provideMerge(infrastructure), Layer.provideMerge(nodeConfigLayer));
+			const ports = Layer.mergeAll(threadStoreLayer, scheduleStoreLayer, nodeWakeSchedulerLayer.pipe(Layer.provideMerge(ownershipDrainLayer.pipe(Layer.provide(submissionLedgerLayer)))));
+			return DurableAgentRuntime.layerWithServices.pipe(Layer.provideMerge(Layer.mergeAll(ports, durableRuntimeConfigLayer(options.estimateCostMicrousd))), Layer.provide(Layer.mergeAll(wakeSchedulerConfigLayer, runtimeFailpointLayer, reconcilerLayer, observerLayer)), Layer.provideMerge(infrastructure), Layer.provideMerge(nodeConfigLayer), Layer.provide(Layer.mergeAll(options.runContext ?? RunContextPreparationPassthrough, options.toolAuthorization ?? RunToolAuthorization.allowAll).pipe(Layer.provide(NodeCrypto.layer))));
 		}));
 	}
 };
@@ -235,10 +234,9 @@ var NodeDurableRuntime = class {
 * Accepted work is unaffected — only NEW admissions are refused.
 */
 var AdmissionClosed = class extends Schema.TaggedError()("AdmissionClosed", { message: Schema.String }) {};
-const makeHost = Effect.gen(function* () {
+const makeHost = (bindings) => Effect.gen(function* () {
 	const runtime = yield* DurableAgentRuntime;
 	const config = yield* NodeDurableRuntimeConfig;
-	const bindingResolver = yield* AgentBindingResolver;
 	const startupRecovery = yield* runtime.runRecovery;
 	const admission = yield* Ref.make(true);
 	yield* Effect.addFinalizer(() => Ref.set(admission, false));
@@ -248,7 +246,7 @@ const makeHost = Effect.gen(function* () {
 		concurrency: "unbounded",
 		discard: true
 	});
-	const runResolvedWorkers = runWorkers(runtime.runResolvedWorker.pipe(Effect.provideService(AgentBindingResolver, bindingResolver)));
+	const runResolvedWorkers = runWorkers(runtime.runResolvedWorker(bindings));
 	return NodeDurableHost.of({
 		startupRecovery,
 		admissionOpen: Ref.get(admission),
@@ -257,7 +255,7 @@ const makeHost = Effect.gen(function* () {
 		observe: runtime.observe,
 		abort: runtime.abort,
 		explain: runtime.explain,
-		explainConversation: runtime.explainConversation,
+		explainThread: runtime.explainThread,
 		verify: runtime.verify,
 		retry: runtime.retry,
 		wake: runtime.wake,
@@ -281,15 +279,31 @@ const makeHost = Effect.gen(function* () {
 * shutdown, provides correctness (DEPLOY-006).
 */
 var NodeDurableHost = class NodeDurableHost extends Context.Service()("@effect-agent/platform-node/NodeDurableHost") {
-	/** Host gates over an already-assembled `NodeDurableRuntime` stack. */
-	static layer = Layer.effect(NodeDurableHost)(makeHost);
+	/**
+	* Compile typed registrations and acquire the complete host in one Layer Scope.
+	* Node supplies Crypto; model, tool, instruction, and schema services remain required.
+	* Startup recovery and shutdown gates are unchanged. Workers start only when the caller
+	* runs runResolvedWorkers; this constructor never starts a background worker.
+	*/
+	static layerRegistered(registrations, options) {
+		return Layer.unwrap(Effect.map(compileRegistrations(registrations), (bindings) => NodeDurableHost.layerStack({
+			...options,
+			bindings
+		}))).pipe(Layer.provide(NodeCrypto.layer));
+	}
+	/**
+	* 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.
+	*/
+	static layer = (bindings = []) => Layer.effect(NodeDurableHost)(makeHost(bindings));
 	/** The complete DN host: `NodeDurableRuntime.layer(options)` plus the host lifecycle gates. */
 	static layerStack(options) {
-		return NodeDurableHost.layer.pipe(Layer.provideMerge(NodeDurableRuntime.layer(options)));
+		const { bindings = [], ...runtimeOptions } = options;
+		return NodeDurableHost.layer(bindings).pipe(Layer.provideMerge(NodeDurableRuntime.layer(runtimeOptions)));
 	}
 };
 //#endregion
-//#region src/scheduling.ts
+//#region src/subscriptions.ts
 const passthroughSubmitAgent = (agentId) => ({ definition: {
 	id: agentId,
 	input: PersistedJson
@@ -299,30 +313,79 @@ const corrupt = (operation) => ScheduleStorageError.make({
 	operation,
 	reason: "corrupt"
 });
-/**
-* Scheduled admission through the existing host gate. Once the gate admits the call, every
-* runtime failure stays ambiguous because the Submission may already have committed.
-*/
-const nodeScheduledInputAdmissionLayer = Layer.effect(ScheduledInputAdmission, Effect.gen(function* () {
+/** Ordinary prepared admission through the Scope-owned Node host gate. */
+const nodePreparedInputAdmissionLayer = Layer.effect(PreparedInputAdmission, Effect.gen(function* () {
 	const host = yield* NodeDurableHost;
-	return ScheduledInputAdmission.of({ submit: (envelope) => host.submit(passthroughSubmitAgent(envelope.agentId), envelope.input, {
-		conversationId: envelope.conversationId,
+	return PreparedInputAdmission.of({ submit: (envelope) => host.submit(passthroughSubmitAgent(envelope.agentId), envelope.input, {
+		threadId: envelope.threadId,
 		principal: envelope.deliveryPrincipal,
 		idempotencyKey: envelope.admissionKey,
 		definitions: envelope.definitions
 	}).pipe(Effect.catchTags({
 		AdmissionClosed: () => Effect.fail(ScheduledInputRetryable.make({ reason: "host-closed" })),
-		AgentInputError: () => Effect.fail(corrupt("scheduled admission input")),
-		AdmissionConflict: () => Effect.fail(corrupt("scheduled admission conflict")),
+		AgentInputError: () => Effect.fail(corrupt("prepared admission input")),
+		AdmissionConflict: () => Effect.fail(corrupt("prepared admission conflict")),
 		DigestError: () => Effect.fail(ambiguous()),
 		LedgerError: () => Effect.fail(ambiguous()),
-		ConversationStoreError: () => Effect.fail(ambiguous()),
-		ConversationNotMaterialized: () => Effect.fail(ambiguous()),
+		ThreadStoreError: () => Effect.fail(ambiguous()),
+		ThreadNotMaterialized: () => Effect.fail(ambiguous()),
 		AppendConflict: () => Effect.fail(ambiguous()),
 		FenceRejected: () => Effect.fail(ambiguous()),
 		DurableRuntimeFailpointError: () => Effect.fail(ambiguous())
 	})) });
 }));
+const preparedFromSchedule = (envelope) => ({
+	schemaVersion: 1,
+	threadId: envelope.threadId,
+	deliveryPrincipal: envelope.deliveryPrincipal,
+	agentId: envelope.agentId,
+	definitions: envelope.definitions,
+	input: envelope.input,
+	inputDigest: envelope.inputDigest,
+	admissionKey: envelope.admissionKey,
+	authorization: envelope.authorization
+});
+const nodeScheduledInputAdmissionLayer = Layer.effect(ScheduledInputAdmission, Effect.map(PreparedInputAdmission, (admission) => ScheduledInputAdmission.of({ submit: (envelope) => admission.submit(preparedFromSchedule(envelope)) }))).pipe(Layer.provide(nodePreparedInputAdmissionLayer));
+const reportPassFailure$1 = (cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.logWarning("Node subscription pass failed").pipe(Effect.annotateLogs({ failureTag: Option.match(Cause.findErrorOption(cause), {
+	onNone: () => "Defect",
+	onSome: (error) => error._tag
+}) }), Effect.as(false));
+const nodeSubscriptionDriverLayer = (limits) => Layer.effectDiscard(Effect.gen(function* () {
+	const driver = yield* SubscriptionDriver;
+	const store = yield* SubscriptionStore;
+	const run = Effect.gen(function* () {
+		while (true) {
+			if (!(yield* driver.runDue.pipe(Effect.map((pass) => pass.failed === 0), Effect.catchCause(reportPassFailure$1)))) {
+				yield* Effect.sleep(Duration.millis(limits.retryMillis));
+				continue;
+			}
+			const deadline = yield* store.nextDeadline.pipe(Effect.exit);
+			if (Exit.isFailure(deadline)) {
+				yield* reportPassFailure$1(deadline.cause);
+				yield* Effect.sleep(Duration.millis(limits.retryMillis));
+				continue;
+			}
+			const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+			const delay = deadline.value === null ? limits.retryMillis : Math.max(1, Math.min(deadline.value - nowMillis, limits.retryMillis));
+			yield* Effect.sleep(Duration.millis(delay));
+		}
+	});
+	yield* Effect.forkScoped(run);
+}));
+/**
+* One Scope-owned subscription partition in the sole process owning its SQLite database.
+* Indexed polling repairs restart and lost wake state; closing the Scope interrupts the driver.
+*/
+var NodeSubscriptions = class {
+	static layer(options = {}) {
+		const limits = options.limits ?? defaultSubscriptionLimits;
+		const publicServices = Layer.merge(Subscriptions.layer(limits), SubscriptionIntake.layer(limits));
+		const driver = nodeSubscriptionDriverLayer(limits).pipe(Layer.provide(SubscriptionDriver.layer(limits)));
+		return Layer.merge(publicServices, driver).pipe(Layer.provide(nodePreparedInputAdmissionLayer), Layer.provide(NodeCrypto.layer));
+	}
+};
+//#endregion
+//#region src/scheduling.ts
 /** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
 const nodeScheduleWakeLayer = Layer.effect(ScheduleWake, Effect.gen(function* () {
 	const hints = yield* PubSub.sliding(1);
@@ -368,6 +431,6 @@ var NodeScheduling = class {
 	}
 };
 //#endregion
-export { AdmissionClosed, NodeDurableHost, NodeDurableRuntime, NodeDurableRuntimeConfig, NodeDurableRuntimeConfigValue, NodePlatformConfigError, NodeScheduling, NodeWakeSchedulerConfig, nodeScheduleWakeLayer, nodeScheduledInputAdmissionLayer, nodeWakeSchedulerLayer, ownershipDrainLayer };
+export { AdmissionClosed, NodeDurableHost, NodeDurableRuntime, NodeDurableRuntimeConfig, NodeDurableRuntimeConfigValue, NodePlatformConfigError, NodeScheduling, NodeSubscriptions, NodeWakeSchedulerConfig, nodePreparedInputAdmissionLayer, nodeScheduleWakeLayer, nodeScheduledInputAdmissionLayer, nodeWakeSchedulerLayer, ownershipDrainLayer };
 
 //# sourceMappingURL=index.mjs.map