@effect-agent/platform-node 0.1.0-beta.37 → 0.1.0-beta.39

package/src/layers.ts

@@ -1,15 +1,27 @@
 import type { SubmissionId } from "@effect-agent/core";
 import {
   CurrentToolFailureObserver,
+  RunContextPreparationPassthrough,
+  RunToolAuthorization,
   toolFailureObserverLayer,
+  type RunContextPreparation,
   type RunCostEstimator,
   type RunToolFailureObserver,
 } from "@effect-agent/engine";
-import type { ScheduleStore } from "@effect-agent/session";
 import {
-  type ConversationStore,
+  threadStoreLayer,
+  scheduleStoreLayer,
+  SqliteStorageConfig,
+  SqliteStorageConfigValue,
+  storageFailpointLayer,
+  submissionLedgerLayer,
+  type SqliteStorageFailpointHandler,
+  type SqliteStorageInitializationError,
+} from "@effect-agent/storage-sqlite";
+import {
+  type ScheduleStore,
+  type ThreadStore,
   type WakeScheduler,
-  AgentBindingResolver,
   DEFAULT_OWNERSHIP_LEASE_DURATION,
   DeploymentId,
   DurableAgentRuntime,
@@ -21,21 +33,10 @@ import {
   ToolReconciler,
   type DurableRuntimeFailpointHandler,
   type OwnershipToken,
-  type ResolvedBinding,
-} from "@effect-agent/session";
-import {
-  conversationStoreLayer,
-  scheduleStoreLayer,
-  SqliteStorageConfig,
-  SqliteStorageConfigValue,
-  storageFailpointLayer,
-  submissionLedgerLayer,
-  type SqliteStorageFailpointHandler,
-  type SqliteStorageInitializationError,
-} from "@effect-agent/storage-sqlite";
+} from "@effect-agent/thread";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
-import { Context, Duration, Effect, Layer, Ref, Schema } from "effect";
+import { Context, type Crypto, Duration, Effect, Layer, Ref, Schema } from "effect";
 
 import { NodeWakeSchedulerConfig, nodeWakeSchedulerLayer } from "./wake-scheduler.ts";
 
@@ -63,7 +64,7 @@ export class NodePlatformConfigError extends Schema.TaggedError<NodePlatformConf
 export class NodeDurableRuntimeConfigValue extends Schema.Class<NodeDurableRuntimeConfigValue>(
   "@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,
@@ -98,7 +99,12 @@ export class NodeDurableRuntimeConfig extends Context.Service<
  * to the documented production values; everything is schema-decoded into
  * `NodeDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
  */
-export interface NodeDurableRuntimeOptions {
+export interface NodeDurableRuntimeOptions<
+  ContextError = never,
+  ContextRequirements = never,
+  AuthorizationError = never,
+  AuthorizationRequirements = never,
+> {
   readonly filename: string;
   readonly deploymentId: string;
   readonly producerId: string;
@@ -135,18 +141,25 @@ export 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. */
 export type NodeDurableRuntimeInitializationError =
   | NodePlatformConfigError
   | SqliteStorageInitializationError;
@@ -155,17 +168,16 @@ export type NodeDurableRuntimeInitializationError =
 export type NodeDurableRuntimeServices =
   | DurableAgentRuntime
   | SubmissionLedger
-  | ConversationStore
+  | ThreadStore
   | ScheduleStore
   | WakeScheduler
   | DurableRuntimeConfig
-  | NodeDurableRuntimeConfig
-  | AgentBindingResolver;
+  | NodeDurableRuntimeConfig;
 
 const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableRuntimeConfigValue);
 
 const configFromOptions = (
-  options: NodeDurableRuntimeOptions,
+  options: Omit<NodeDurableRuntimeOptions, "runContext" | "toolAuthorization">,
 ): Effect.Effect<NodeDurableRuntimeConfigValue, NodePlatformConfigError> =>
   decodeConfigValue({
     filename: options.filename,
@@ -204,7 +216,7 @@ const sqliteStorageConfigLayer: Layer.Layer<SqliteStorageConfig, never, NodeDura
     }),
   );
 
-/** Session coordinator configuration derived from the single validated Node configuration. */
+/** Thread coordinator configuration derived from the single validated Node configuration. */
 const durableRuntimeConfigLayer = (
   estimateCostMicrousd: RunCostEstimator | undefined,
 ): Layer.Layer<DurableRuntimeConfig, never, NodeDurableRuntimeConfig> =>
@@ -344,7 +356,7 @@ export const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissio
 /**
  * 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
@@ -354,16 +366,40 @@ export const ownershipDrainLayer: Layer.Layer<SubmissionLedger, never, Submissio
  */
 export class NodeDurableRuntime {
   /** Validated configuration Layer; fails typed when the supplied options are out of bounds. */
-  static configLayer(
-    options: NodeDurableRuntimeOptions,
+  static configLayer<
+    ContextError = never,
+    ContextRequirements = never,
+    AuthorizationError = never,
+    AuthorizationRequirements = never,
+  >(
+    options: NodeDurableRuntimeOptions<
+      ContextError,
+      ContextRequirements,
+      AuthorizationError,
+      AuthorizationRequirements
+    >,
   ): Layer.Layer<NodeDurableRuntimeConfig, NodePlatformConfigError> {
     return Layer.effect(NodeDurableRuntimeConfig)(configFromOptions(options));
   }
 
   /** 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>
+  > {
     return Layer.unwrap(
       Effect.map(configFromOptions(options), (config) => {
         const nodeConfigLayer = Layer.succeed(NodeDurableRuntimeConfig)(config);
@@ -385,21 +421,16 @@ export class NodeDurableRuntime {
           options.toolFailureObserver === undefined
             ? Layer.succeed(CurrentToolFailureObserver)(undefined)
             : toolFailureObserverLayer(options.toolFailureObserver);
-        const bindingResolverLayer = AgentBindingResolver.layer(options.bindings ?? []);
         const ports = Layer.mergeAll(
-          conversationStoreLayer,
+          threadStoreLayer,
           scheduleStoreLayer,
           nodeWakeSchedulerLayer.pipe(
             Layer.provideMerge(ownershipDrainLayer.pipe(Layer.provide(submissionLedgerLayer))),
           ),
         );
-        return DurableAgentRuntime.layer.pipe(
+        return DurableAgentRuntime.layerWithServices.pipe(
           Layer.provideMerge(
-            Layer.mergeAll(
-              ports,
-              durableRuntimeConfigLayer(options.estimateCostMicrousd),
-              bindingResolverLayer,
-            ),
+            Layer.mergeAll(ports, durableRuntimeConfigLayer(options.estimateCostMicrousd)),
           ),
           Layer.provide(
             Layer.mergeAll(
@@ -411,6 +442,12 @@ export class NodeDurableRuntime {
           ),
           Layer.provideMerge(infrastructure),
           Layer.provideMerge(nodeConfigLayer),
+          Layer.provide(
+            Layer.mergeAll(
+              options.runContext ?? RunContextPreparationPassthrough,
+              options.toolAuthorization ?? RunToolAuthorization.allowAll,
+            ).pipe(Layer.provide(NodeCrypto.layer)),
+          ),
         );
       }),
     );

package/src/scheduling.ts

@@ -1,74 +1,20 @@
-import type { AgentId } from "@effect-agent/core";
 import {
-  type DurableSubmitAgent,
   type ScheduleProcessFailure,
   type ScheduleAuthorizer,
   type SchedulingLimits,
   ScheduleStorageError,
   ScheduleStore,
   type ScheduleValidationError,
-  ScheduledInputAdmission,
-  ScheduledInputRetryable,
   ScheduleWake,
   Scheduling,
   ScheduleDriver,
   defaultSchedulingLimits,
-  PersistedJson,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { NodeCrypto } from "@effect/platform-node";
 import { Cause, Duration, Effect, Layer, Option, PubSub, Result } from "effect";
 
-import { NodeDurableHost } from "./host.ts";
-
-const passthroughSubmitAgent = (agentId: AgentId): DurableSubmitAgent<typeof PersistedJson> => ({
-  definition: { id: agentId, input: PersistedJson },
-});
-
-const ambiguous = (): ScheduledInputRetryable =>
-  ScheduledInputRetryable.make({ reason: "ambiguous" });
-
-const corrupt = (operation: string): ScheduleStorageError =>
-  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.
- */
-export const nodeScheduledInputAdmissionLayer: Layer.Layer<
-  ScheduledInputAdmission,
-  never,
-  NodeDurableHost
-> = Layer.effect(
-  ScheduledInputAdmission,
-  Effect.gen(function* () {
-    const host = yield* NodeDurableHost;
-    return ScheduledInputAdmission.of({
-      submit: (envelope) =>
-        host
-          .submit(passthroughSubmitAgent(envelope.agentId), envelope.input, {
-            conversationId: envelope.conversationId,
-            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")),
-              DigestError: () => Effect.fail(ambiguous()),
-              LedgerError: () => Effect.fail(ambiguous()),
-              ConversationStoreError: () => Effect.fail(ambiguous()),
-              ConversationNotMaterialized: () => Effect.fail(ambiguous()),
-              AppendConflict: () => Effect.fail(ambiguous()),
-              FenceRejected: () => Effect.fail(ambiguous()),
-              DurableRuntimeFailpointError: () => Effect.fail(ambiguous()),
-            }),
-          ),
-    });
-  }),
-);
+import type { NodeDurableHost } from "./host.ts";
+import { nodeScheduledInputAdmissionLayer } from "./subscriptions.ts";
 
 /** One bounded hint slot for the single supported Node scheduler. Indexed polling repairs loss. */
 export const nodeScheduleWakeLayer: Layer.Layer<ScheduleWake> = Layer.effect(

package/src/subscriptions.ts

@@ -0,0 +1,195 @@
+import type { AgentId } from "@effect-agent/core";
+import {
+  type DurableSubmitAgent,
+  type EventSources,
+  type SubscriptionInputBindings,
+  PersistedJson,
+  type PreparedInput,
+  PreparedInputAdmission,
+  type ScheduledEnvelope,
+  ScheduledInputAdmission,
+  ScheduledInputRetryable,
+  type SubscriptionAuthorizer,
+  SubscriptionDriver,
+  type SubscriptionError,
+  SubscriptionIntake,
+  type SubscriptionLimits,
+  type SubscriptionStoreFailure,
+  SubscriptionStore,
+  Subscriptions,
+  defaultSubscriptionLimits,
+  ScheduleStorageError,
+} from "@effect-agent/thread";
+import { NodeCrypto } from "@effect/platform-node";
+import { Cause, Duration, Effect, Exit, Layer, Option } from "effect";
+
+import { NodeDurableHost } from "./host.ts";
+
+const passthroughSubmitAgent = (agentId: AgentId): DurableSubmitAgent<typeof PersistedJson> => ({
+  definition: { id: agentId, input: PersistedJson },
+});
+
+const ambiguous = (): ScheduledInputRetryable =>
+  ScheduledInputRetryable.make({ reason: "ambiguous" });
+
+const corrupt = (operation: string): ScheduleStorageError =>
+  ScheduleStorageError.make({ operation, reason: "corrupt" });
+
+/** Ordinary prepared admission through the Scope-owned Node host gate. */
+export const nodePreparedInputAdmissionLayer: Layer.Layer<
+  PreparedInputAdmission,
+  never,
+  NodeDurableHost
+> = Layer.effect(
+  PreparedInputAdmission,
+  Effect.gen(function* () {
+    const host = yield* NodeDurableHost;
+    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("prepared admission input")),
+              AdmissionConflict: () => Effect.fail(corrupt("prepared admission conflict")),
+              DigestError: () => Effect.fail(ambiguous()),
+              LedgerError: () => 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: ScheduledEnvelope): PreparedInput => ({
+  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,
+});
+
+/** Compatibility adapter retaining the public scheduling admission port. */
+const nodeScheduledInputAdmissionFromPreparedLayer: Layer.Layer<
+  ScheduledInputAdmission,
+  never,
+  PreparedInputAdmission
+> = Layer.effect(
+  ScheduledInputAdmission,
+  Effect.map(PreparedInputAdmission, (admission) =>
+    ScheduledInputAdmission.of({
+      submit: (envelope) => admission.submit(preparedFromSchedule(envelope)),
+    }),
+  ),
+);
+
+export const nodeScheduledInputAdmissionLayer: Layer.Layer<
+  ScheduledInputAdmission,
+  never,
+  NodeDurableHost
+> = nodeScheduledInputAdmissionFromPreparedLayer.pipe(
+  Layer.provide(nodePreparedInputAdmissionLayer),
+);
+
+const reportPassFailure = (cause: Cause.Cause<SubscriptionStoreFailure>): Effect.Effect<boolean> =>
+  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: SubscriptionLimits,
+): Layer.Layer<never, never, SubscriptionDriver | SubscriptionStore> =>
+  Layer.effectDiscard(
+    Effect.gen(function* () {
+      const driver = yield* SubscriptionDriver;
+      const store = yield* SubscriptionStore;
+
+      const run = Effect.gen(function* () {
+        while (true) {
+          const passSucceeded = yield* driver.runDue.pipe(
+            Effect.map((pass) => pass.failed === 0),
+            Effect.catchCause(reportPassFailure),
+          );
+
+          if (!passSucceeded) {
+            yield* Effect.sleep(Duration.millis(limits.retryMillis));
+            continue;
+          }
+
+          const deadline = yield* store.nextDeadline.pipe(Effect.exit);
+          if (Exit.isFailure(deadline)) {
+            yield* reportPassFailure(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);
+    }),
+  );
+
+export 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.
+ */
+export class NodeSubscriptions {
+  static layer(
+    options: NodeSubscriptionsOptions = {},
+  ): Layer.Layer<
+    Subscriptions | SubscriptionIntake,
+    SubscriptionError,
+    | NodeDurableHost
+    | SubscriptionStore
+    | SubscriptionAuthorizer
+    | EventSources
+    | SubscriptionInputBindings
+  > {
+    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),
+    );
+  }
+}

package/src/wake-scheduler.ts

@@ -1,6 +1,7 @@
-import type { ConversationId } from "@effect-agent/core";
-import { makeWakeSubscriptionHub, SubmissionLedger, WakeScheduler } from "@effect-agent/session";
-import { Context, Duration, Effect, Layer, PubSub, Stream } from "effect";
+import type { ThreadId } from "@effect-agent/core";
+import { makeWakeSubscriptionHub, SubmissionLedger, WakeScheduler } from "@effect-agent/thread";
+import type { Duration } from "effect";
+import { Context, Effect, Layer, PubSub, Stream } from "effect";
 
 /**
  * Bounded in-process wake buffer. Wake hints are droppable by contract (the ledger-scan fallback
@@ -12,7 +13,7 @@ const WAKE_BUFFER_CAPACITY = 1_024;
 export class NodeWakeSchedulerConfig extends Context.Service<
   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;
   }
 >()("@effect-agent/platform-node/NodeWakeSchedulerConfig") {
@@ -26,28 +27,28 @@ export class NodeWakeSchedulerConfig extends Context.Service<
 const makeWakeScheduler = Effect.gen(function* () {
   const ledger = yield* SubmissionLedger;
   const config = yield* NodeWakeSchedulerConfig;
-  const hints = yield* PubSub.sliding<ConversationId>(WAKE_BUFFER_CAPACITY);
+  const hints = yield* PubSub.sliding<ThreadId>(WAKE_BUFFER_CAPACITY);
   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: Effect.Effect<ReadonlyArray<ConversationId>> = Stream.runCollect(
+  const scanOnce: Effect.Effect<ReadonlyArray<ThreadId>> = Stream.runCollect(
     ledger.scanNonterminal,
   ).pipe(
     Effect.map((snapshots) => {
-      const lanes = new Set<ConversationId>();
+      const lanes = new Set<ThreadId>();
       for (const snapshot of snapshots) {
-        lanes.add(snapshot.conversationId);
+        lanes.add(snapshot.threadId);
       }
       return [...lanes];
     }),
     Effect.catch((error) =>
       Effect.logWarning("NodeWakeScheduler fallback scan failed", error).pipe(
-        Effect.as([] as ReadonlyArray<ConversationId>),
+        Effect.as([] as ReadonlyArray<ThreadId>),
       ),
     ),
   );
@@ -57,15 +58,15 @@ const makeWakeScheduler = Effect.gen(function* () {
    * merges its PubSub subscription with a Clock-driven ledger-scan loop. Both live entirely in
    * the consuming run's Scope; no fiber outlives its subscriber.
    */
-  const fallbackScans: Stream.Stream<ConversationId> = Stream.fromIterableEffectRepeat(
+  const fallbackScans: Stream.Stream<ThreadId> = Stream.fromIterableEffectRepeat(
     Effect.sleep(config.scanInterval).pipe(Effect.andThen(scanOnce)),
   );
 
   return WakeScheduler.of({
-    notify: (conversationId) =>
+    notify: (threadId) =>
       progress
-        .notify(conversationId)
-        .pipe(Effect.andThen(PubSub.publish(hints, conversationId)), Effect.asVoid),
+        .notify(threadId)
+        .pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.asVoid),
     subscribe: progress.subscribe,
     wakes: Stream.merge(Stream.fromPubSub(hints), fallbackScans),
   });