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

package/dist/index.mjs

@@ -1,444 +1,6 @@
-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, defaultSchedulingLimits, defaultSubscriptionLimits, makeWakeSubscriptionHub } from "@effect-agent/thread";
-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 { NodeCrypto } from "@effect/platform-node";
-import { SqliteClient } from "@effect/sql-sqlite-node";
-//#region src/wake-scheduler.ts
-/**
-* Bounded in-process wake buffer. Wake hints are droppable by contract (the ledger-scan fallback
-* keeps liveness), so a full buffer slides out the oldest hint instead of growing without bound.
-*/
-const WAKE_BUFFER_CAPACITY = 1024;
-/** Cadence authority for the Node wake scheduler's ledger-scan fallback loop. */
-var NodeWakeSchedulerConfig = class NodeWakeSchedulerConfig extends Context.Service()("@effect-agent/platform-node/NodeWakeSchedulerConfig") {
-	static layer(options) {
-		return Layer.succeed(NodeWakeSchedulerConfig)({ scanInterval: options.scanInterval });
-	}
-};
-const makeWakeScheduler = Effect.gen(function* () {
-	const ledger = yield* SubmissionLedger;
-	const config = yield* NodeWakeSchedulerConfig;
-	const hints = yield* PubSub.sliding(WAKE_BUFFER_CAPACITY);
-	const progress = yield* makeWakeSubscriptionHub;
-	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
-	/**
-	* 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.threadId);
-		return [...lanes];
-	}), Effect.catch((error) => Effect.logWarning("NodeWakeScheduler fallback scan failed", error).pipe(Effect.as([]))));
-	/**
-	* Deployment §3: correctness must not depend on in-memory notifications, so every `wakes` run
-	* 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.fromIterableEffectRepeat(Effect.sleep(config.scanInterval).pipe(Effect.andThen(scanOnce)));
-	return WakeScheduler.of({
-		notify: (threadId) => progress.notify(threadId).pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.asVoid),
-		subscribe: progress.subscribe,
-		wakes: Stream.merge(Stream.fromPubSub(hints), fallbackScans)
-	});
-});
-/**
-* In-process Node `WakeScheduler`: `notify` publishes to a bounded sliding PubSub for prompt
-* same-process wakeups, and every `wakes` subscription additionally runs a periodic
-* `SubmissionLedger.scanNonterminal` fallback so a dropped, coalesced, or never-sent notification
-* can never strand accepted work (persistence §14). Delivery may duplicate; consumers already
-* treat wakes as pure liveness hints.
-*/
-const nodeWakeSchedulerLayer = Layer.effect(WakeScheduler)(makeWakeScheduler);
-//#endregion
-//#region src/layers.ts
-const PositiveMillis = Schema.Int.check(Schema.isGreaterThan(0));
-const NonNegativeMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const WorkerConcurrency = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(64));
-/** The supplied Node durable runtime configuration failed schema validation (DEPLOY-003). */
-var NodePlatformConfigError = class extends Schema.TaggedError()("NodePlatformConfigError", {
-	message: Schema.String,
-	cause: Schema.optionalKey(Schema.Defect())
-}) {};
-/**
-* Validated Node durable runtime configuration (deployment §4: decoded once during Layer
-* 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.
-*/
-var NodeDurableAgentRuntimeConfigValue = class extends Schema.Class("@effect-agent/platform-node/NodeDurableAgentRuntimeConfigValue")({
-	/** SQLite database file backing BOTH the Thread Log and the Submission Ledger. */
-	filename: Schema.NonEmptyString,
-	deploymentId: DeploymentId,
-	producerId: ProducerId,
-	/** Submission ownership lease duration (D5); liveness hint only, epochs stay authoritative. */
-	ownershipLeaseDuration: PositiveMillis,
-	/** Finite bound on concurrent worker loops per host (rule 10). */
-	workerConcurrency: WorkerConcurrency,
-	/** Ledger-scan fallback cadence of the Node wake scheduler (deployment §3). */
-	wakeScanInterval: PositiveMillis,
-	/** `awaitSettlement` ledger re-check cadence when no wake arrives. */
-	settlementPollInterval: PositiveMillis,
-	/** Worker ownership-lease renewal cadence. */
-	leaseRenewalInterval: PositiveMillis,
-	/** Active-Run abort-intent poll cadence. */
-	abortPollInterval: PositiveMillis,
-	/** Bounded SQLITE_BUSY retry window for write-lock acquisition. */
-	busyTimeout: NonNegativeMillis,
-	/** Canonical observation poll cadence of the SQLite store. */
-	observationPollInterval: NonNegativeMillis,
-	/** Opt-in full payload/digest-chain audit while opening the store. */
-	verifyOnOpen: Schema.Boolean
-}) {};
-/** Explicit configuration authority for the assembled Node durable runtime. */
-var NodeDurableAgentRuntimeConfig = class extends Context.Service()("@effect-agent/platform-node/NodeDurableAgentRuntimeConfig") {};
-const decodeConfigValue = Schema.decodeUnknownEffect(NodeDurableAgentRuntimeConfigValue);
-const configFromOptions = (options) => decodeConfigValue({
-	filename: options.filename,
-	deploymentId: options.deploymentId,
-	producerId: options.producerId,
-	ownershipLeaseDuration: options.ownershipLeaseDuration ?? Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
-	workerConcurrency: options.workerConcurrency ?? 1,
-	wakeScanInterval: options.wakeScanInterval ?? 1e3,
-	settlementPollInterval: options.settlementPollInterval ?? 500,
-	leaseRenewalInterval: options.leaseRenewalInterval ?? 1e4,
-	abortPollInterval: options.abortPollInterval ?? 500,
-	busyTimeout: options.busyTimeout ?? 5e3,
-	observationPollInterval: options.observationPollInterval ?? 25,
-	verifyOnOpen: options.verifyOnOpen ?? false
-}).pipe(Effect.mapError((error) => NodePlatformConfigError.make({
-	message: `Invalid Node durable runtime configuration: ${error.message}`,
-	cause: error
-})));
-/** SQLite storage configuration derived from the single validated Node configuration. */
-const sqliteStorageConfigLayer = 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) => Layer.effect(DurableRuntimeConfig)(Effect.gen(function* () {
-	const config = yield* NodeDurableAgentRuntimeConfig;
-	return DurableRuntimeConfig.make({
-		deploymentId: config.deploymentId,
-		producerId: config.producerId,
-		settlementPollInterval: Duration.millis(config.settlementPollInterval),
-		leaseRenewalInterval: Duration.millis(config.leaseRenewalInterval),
-		abortPollInterval: Duration.millis(config.abortPollInterval),
-		...estimateCostMicrousd === void 0 ? {} : { estimateCostMicrousd }
-	});
-}));
-/** Wake fallback-scan cadence derived from the single validated Node configuration. */
-const wakeSchedulerConfigLayer = Layer.effect(NodeWakeSchedulerConfig)(Effect.gen(function* () {
-	const config = yield* NodeDurableAgentRuntimeConfig;
-	return { scanInterval: Duration.millis(config.wakeScanInterval) };
-}));
-const releaseTrackedOwnership = (ledger, registry) => Effect.gen(function* () {
-	const tracked = yield* Ref.getAndSet(registry, /* @__PURE__ */ new Map());
-	for (const [submissionId, ownershipToken] of tracked) yield* ledger.releaseOwnership(ReleaseOwnershipRequest.make({
-		submissionId,
-		ownershipToken
-	})).pipe(Effect.catchTags({
-		OwnershipLost: () => Effect.void,
-		LedgerError: (error) => Effect.logWarning("Ownership drain failed; the lease will expire instead", error)
-	}));
-});
-/**
-* 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
-* rotation, releases and settlement finalizations stop it — and every ownership still held when
-* the Layer's Scope closes is released so another host can claim the lane immediately instead of
-* waiting for lease expiry. The drain is a liveness courtesy only; producer-epoch fencing remains
-* the correctness authority (DUR-006), and a forced kill simply falls back to lease expiry.
-*/
-const ownershipDrainLayer = Layer.effect(SubmissionLedger)(Effect.gen(function* () {
-	const ledger = yield* SubmissionLedger;
-	const registry = yield* Ref.make(/* @__PURE__ */ new Map());
-	const track = (submissionId, ownershipToken) => Ref.update(registry, (tracked) => new Map(tracked).set(submissionId, ownershipToken));
-	const untrack = (submissionId) => Ref.update(registry, (tracked) => {
-		const next = new Map(tracked);
-		next.delete(submissionId);
-		return next;
-	});
-	yield* Effect.addFinalizer(() => releaseTrackedOwnership(ledger, registry));
-	return SubmissionLedger.of({
-		capabilities: ledger.capabilities,
-		admit: ledger.admit,
-		markReady: ledger.markReady,
-		lookup: ledger.lookup,
-		resolveAdmission: ledger.resolveAdmission,
-		recordChildSettled: ledger.recordChildSettled,
-		reserveChildBudget: ledger.reserveChildBudget,
-		attachChildToReservation: ledger.attachChildToReservation,
-		beginChildBudgetRelease: ledger.beginChildBudgetRelease,
-		releaseChildBudget: ledger.releaseChildBudget,
-		claim: (request) => ledger.claim(request).pipe(Effect.tap((claimed) => claimed._tag === "Some" ? track(claimed.value.submissionId, claimed.value.ownershipToken) : Effect.void)),
-		renewOwnership: (request) => ledger.renewOwnership(request).pipe(Effect.tap((renewal) => track(request.submissionId, renewal.ownershipToken)), Effect.tapError((error) => error._tag === "OwnershipLost" ? untrack(request.submissionId) : Effect.void)),
-		releaseOwnership: (request) => ledger.releaseOwnership(request).pipe(Effect.tap(() => untrack(request.submissionId)), Effect.tapError((error) => error._tag === "OwnershipLost" ? untrack(request.submissionId) : Effect.void)),
-		markInputApplied: ledger.markInputApplied,
-		reserveSettlement: ledger.reserveSettlement,
-		finalizeSettlement: (request) => ledger.finalizeSettlement(request).pipe(Effect.tap(() => untrack(request.submissionId))),
-		requestAbort: ledger.requestAbort,
-		claimJoining: ledger.claimJoining,
-		markJoined: ledger.markJoined,
-		revertJoining: ledger.revertJoining,
-		suspend: (request) => ledger.suspend(request).pipe(Effect.tap(() => untrack(request.submissionId))),
-		recordApprovalDecision: ledger.recordApprovalDecision,
-		markUnknown: ledger.markUnknown,
-		recordUnknownResolution: ledger.recordUnknownResolution,
-		scanNonterminal: ledger.scanNonterminal,
-		loadRecoverySnapshot: ledger.loadRecoverySnapshot
-	});
-}));
-/**
-* 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
-* 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
-* `DurableAgentRuntime` on top. Storage compatibility is
-* verified during construction: an incompatible database file fails the Layer with
-* `SqliteStorageCompatibilityError` before anything is mutated (DEPLOY-008).
-*/
-var NodeDurableAgentRuntime = class NodeDurableAgentRuntime {
-	/** Validated configuration Layer; fails typed when the supplied options are out of bounds. */
-	static configLayer(options) {
-		return Layer.effect(NodeDurableAgentRuntimeConfig)(configFromOptions(options));
-	}
-	/** The full DN runtime stack over one SQLite file. */
-	static layer(options) {
-		return NodeDurableAgentRuntime.assemble(DurableAgentRuntime.layerWithServices, options);
-	}
-	/** Own typed executable registrations for every worker using this Node runtime. */
-	static layerRegistered(registrations, options) {
-		return NodeDurableAgentRuntime.assemble(DurableAgentRuntime.layerRegistered(registrations), options);
-	}
-	/** Construct from registrations already resolved within the enclosing application Scope. */
-	static layerWithBindings(bindings, options) {
-		return NodeDurableAgentRuntime.assemble(DurableAgentRuntime.layerWithBindings(bindings), options);
-	}
-	static assemble(runtimeLayer, options) {
-		return Layer.unwrap(Effect.map(configFromOptions(options), (config) => {
-			const nodeConfigLayer = Layer.succeed(NodeDurableAgentRuntimeConfig)(config);
-			const infrastructure = Layer.mergeAll(sqliteStorageConfigLayer, storageFailpointLayer({
-				filename: config.filename,
-				failpoint: options.storageFailpoint
-			}), SqliteClient.layer({ filename: config.filename }), NodeCrypto.layer);
-			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 ports = Layer.mergeAll(threadStoreLayer, scheduleStoreLayer, nodeWakeSchedulerLayer.pipe(Layer.provideMerge(ownershipDrainLayer.pipe(Layer.provide(submissionLedgerLayer)))));
-			return runtimeLayer.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))));
-		}));
-	}
-};
-//#endregion
-//#region src/host.ts
-/**
-* Admission is not open on this host: it is shutting down (deployment §6 step 1, DEPLOY-005).
-* 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 runtime = yield* DurableAgentRuntime;
-	const config = yield* NodeDurableAgentRuntimeConfig;
-	const startupRecovery = yield* runtime.runRecovery;
-	const admission = yield* Ref.make(true);
-	yield* Effect.addFinalizer(() => Ref.set(admission, false));
-	const requireAdmission = 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 = (agent, input, options) => requireAdmission.pipe(Effect.andThen(runtime.submit(agent, input, options)));
-	const runWorkers = (worker) => Effect.forEach(Array.from({ length: config.workerConcurrency }, (_, index) => index), () => worker, {
-		concurrency: "unbounded",
-		discard: true
-	});
-	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
-	});
-});
-/**
-* Operational host lifecycle for the DN runtime (deployment §2/§5/§6).
-*
-* Startup gates run during Layer construction, so the service existing implies readiness:
-* configuration was schema-decoded, the SQLite file passed the exact-version compatibility check,
-* and every nonterminal Submission went through one full recovery pass BEFORE admission opened.
-* `startupRecovery` is the auditable evidence of that reconciliation pass.
-*
-* Shutdown runs in reverse Layer order when the owning Scope closes: `submit` starts refusing
-* with `AdmissionClosed` first, then the runtime Layer's ownership drain releases every claim
-* still held so another host can take over the lanes immediately, then the SQLite resources
-* close. Forced termination at any point stays safe — the durability protocol, not graceful
-* shutdown, provides correctness (DEPLOY-006).
-*/
-var NodeDurableHost = class NodeDurableHost extends Context.Service()("@effect-agent/platform-node/NodeDurableHost") {
-	/**
-	* 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 NodeDurableHost.layer.pipe(Layer.provideMerge(NodeDurableAgentRuntime.layerRegistered(registrations, options)));
-	}
-	/**
-	* Host gates over an assembled `NodeDurableAgentRuntime` stack. The runtime Layer owns
-	* executable registrations; omission registers no Agents, so resolved work fails closed.
-	*/
-	static layer = Layer.effect(NodeDurableHost)(makeHost);
-	/** The complete DN host: `NodeDurableAgentRuntime.layer(options)` plus the host lifecycle gates. */
-	static layerStack(options) {
-		const { bindings = [], ...runtimeOptions } = options;
-		return NodeDurableHost.layer.pipe(Layer.provideMerge(NodeDurableAgentRuntime.layerWithBindings(bindings, runtimeOptions)));
-	}
-};
-//#endregion
-//#region src/subscriptions.ts
-const passthroughSubmitAgent = (agentId) => ({ definition: {
-	id: agentId,
-	input: PersistedJson
-} });
-const ambiguous = () => ScheduledInputRetryable.make({ reason: "ambiguous" });
-const corrupt = (operation) => ScheduleStorageError.make({
-	operation,
-	reason: "corrupt"
-});
-/** Ordinary prepared admission through the Scope-owned Node host gate. */
-const nodePreparedInputAdmissionLayer = 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) => ({
-	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);
-	const subscription = yield* PubSub.subscribe(hints);
-	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
-	return ScheduleWake.of({
-		notify: PubSub.publish(hints, void 0).pipe(Effect.asVoid),
-		await: PubSub.take(subscription)
-	});
-}));
-const reportPassFailure = (cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.logWarning("Node scheduling pass failed").pipe(Effect.annotateLogs({ failureTag: Option.match(Cause.findErrorOption(cause), {
-	onNone: () => "Defect",
-	onSome: (error) => error._tag
-}) }), Effect.as(false));
-const nodeSchedulingDriverLayer = (limits) => Layer.effectDiscard(Effect.gen(function* () {
-	const scheduling = yield* ScheduleDriver;
-	const store = yield* ScheduleStore;
-	const wake = yield* ScheduleWake;
-	const run = Effect.gen(function* () {
-		while (true) {
-			const passSucceeded = yield* scheduling.runDue().pipe(Effect.map((pass) => pass.failed === 0), Effect.catchCause(reportPassFailure));
-			const deadlineResult = passSucceeded ? yield* store.nextDeadline().pipe(Effect.result) : Result.fail(ScheduleStorageError.make({
-				operation: "driver pass",
-				reason: "unavailable"
-			}));
-			if (Result.isFailure(deadlineResult) && passSucceeded) yield* Effect.logWarning("Node scheduling deadline query failed");
-			const nowMillis = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
-			const deadlineDelay = Result.isSuccess(deadlineResult) && deadlineResult.success !== null ? Math.max(0, deadlineResult.success - nowMillis) : limits.recoveryPollMillis;
-			const delay = Math.min(deadlineDelay, limits.recoveryPollMillis);
-			yield* Effect.raceFirst(wake.await, Effect.sleep(Duration.millis(delay)));
-		}
-	});
-	yield* Effect.forkScoped(run);
-}));
-/**
-* Optional Scope-owned Node scheduling service and driver. The caller must provide the existing
-* host, its SQLite ScheduleStore, and an explicit ScheduleAuthorizer.
-*/
-var NodeScheduling = class {
-	static layer(options = {}) {
-		const limits = options.limits ?? defaultSchedulingLimits;
-		return nodeSchedulingDriverLayer(limits).pipe(Layer.provide(ScheduleDriver.layer(limits)), Layer.merge(Scheduling.layer(limits))).pipe(Layer.provide(Layer.mergeAll(nodeScheduledInputAdmissionLayer, nodeScheduleWakeLayer, NodeCrypto.layer)));
-	}
-};
-//#endregion
-export { AdmissionClosed, NodeDurableAgentRuntime, NodeDurableAgentRuntimeConfig, NodeDurableAgentRuntimeConfigValue, NodeDurableHost, NodePlatformConfigError, NodeScheduling, NodeSubscriptions, NodeWakeSchedulerConfig, nodePreparedInputAdmissionLayer, nodeScheduleWakeLayer, nodeScheduledInputAdmissionLayer, nodeWakeSchedulerLayer, ownershipDrainLayer };
-
-//# sourceMappingURL=index.mjs.map
+import { t as NodeWakeScheduler_exports } from "./NodeWakeScheduler.mjs";
+import { t as NodeDurableAgentRuntime_exports } from "./NodeDurableAgentRuntime.mjs";
+import { t as NodeDurableHost_exports } from "./NodeDurableHost.mjs";
+import { t as NodeSubscriptions_exports } from "./NodeSubscriptions.mjs";
+import { t as NodeScheduling_exports } from "./NodeScheduling.mjs";
+export { NodeDurableAgentRuntime_exports as NodeDurableAgentRuntime, NodeDurableHost_exports as NodeDurableHost, NodeScheduling_exports as NodeScheduling, NodeSubscriptions_exports as NodeSubscriptions, NodeWakeScheduler_exports as NodeWakeScheduler };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1 +1 @@
-{"name":"@effect-agent/platform-node","version":"0.1.0-beta.45","dependencies":{"@effect-agent/core":"0.1.0-beta.45","@effect-agent/engine":"0.1.0-beta.45","@effect-agent/storage-sqlite":"0.1.0-beta.45","@effect-agent/thread":"0.1.0-beta.45","@effect-agent/workflow":"0.1.0-beta.45","@effect/platform-node":"4.0.0-rc.112","@effect/sql-sqlite-node":"4.0.0-rc.112"},"devDependencies":{"@effect-agent/capabilities":"0.1.0-beta.45","@effect/vitest":"4.0.0-rc.112","effect":"4.0.0-rc.112","typescript":"7.0.2","vite-plus":"0.3.0"},"peerDependencies":{"effect":"^4.0.0-rc.112"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./workflow":{"types":"./dist/workflow.d.mts","default":"./dist/workflow.mjs"}},"description":"Class DN layer assembly for Effect Agent: the durable Node/SQLite runtime host, wake scheduler, and ownership drain.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/platform-node"},"files":["dist","src"],"type":"module","publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test --passWithNoTests"}}
+{"name":"@effect-agent/platform-node","version":"0.1.0-beta.46","dependencies":{"@effect-agent/core":"0.1.0-beta.46","@effect-agent/engine":"0.1.0-beta.46","@effect-agent/storage-sqlite":"0.1.0-beta.46","@effect-agent/thread":"0.1.0-beta.46","@effect-agent/workflow":"0.1.0-beta.46","@effect/platform-node":"4.0.0-rc.112","@effect/sql-sqlite-node":"4.0.0-rc.112"},"devDependencies":{"@effect-agent/capabilities":"0.1.0-beta.46","@effect/vitest":"4.0.0-rc.112","effect":"4.0.0-rc.112","typescript":"7.0.2","vite-plus":"0.3.0"},"peerDependencies":{"effect":"^4.0.0-rc.112"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./NodeDurableAgentRuntime":{"types":"./dist/NodeDurableAgentRuntime.d.mts","default":"./dist/NodeDurableAgentRuntime.mjs"},"./NodeDurableHost":{"types":"./dist/NodeDurableHost.d.mts","default":"./dist/NodeDurableHost.mjs"},"./NodeScheduling":{"types":"./dist/NodeScheduling.d.mts","default":"./dist/NodeScheduling.mjs"},"./NodeSubscriptions":{"types":"./dist/NodeSubscriptions.d.mts","default":"./dist/NodeSubscriptions.mjs"},"./NodeWakeScheduler":{"types":"./dist/NodeWakeScheduler.d.mts","default":"./dist/NodeWakeScheduler.mjs"},"./NodeWorkflow":{"types":"./dist/NodeWorkflow.d.mts","default":"./dist/NodeWorkflow.mjs"}},"description":"Class DN layer assembly for Effect Agent: the durable Node/SQLite runtime host, wake scheduler, and ownership drain.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/platform-node"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test --passWithNoTests"}}

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,40 +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,
-  type ScheduleStore,
-  type ThreadStore,
-  type WakeScheduler,
-  DEFAULT_OWNERSHIP_LEASE_DURATION,
-  DeploymentId,
+} from "@effect-agent/thread/AgentRegistration";
+import {
   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));

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

@@ -1,16 +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 {
   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,
@@ -20,16 +24,20 @@ 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";
+} 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 {
@@ -38,7 +46,7 @@ import {
   type NodeDurableAgentRuntimeInitializationError,
   type NodeDurableAgentRuntimeOptions,
   type NodeDurableAgentRuntimeServices,
-} from "./layers.ts";
+} from "./NodeDurableAgentRuntime.ts";
 
 /**
  * Admission is not open on this host: it is shutting down (deployment §6 step 1, DEPLOY-005).

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(