effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/durable/ToolReconciler.d.mts

@@ -0,0 +1,2 @@
+import { a as ReconciliationSafeToRetry, c as ToolReconcilerError, i as ReconciliationNeverStarted, n as ReconciliationCompleted, o as ReconciliationUncertain, r as ReconciliationDecision, s as ToolReconciler, t as PreparedToolCallEvidence } from "../ToolReconciler-BmVRAHKs.mjs";
+export { PreparedToolCallEvidence, ReconciliationCompleted, ReconciliationDecision, ReconciliationNeverStarted, ReconciliationSafeToRetry, ReconciliationUncertain, ToolReconciler, ToolReconcilerError };

package/dist/durable/ToolReconciler.mjs

@@ -0,0 +1,85 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { RunId, SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.mjs";
+import { Digest, PersistedJson, ToolCallPrepared } from "./Records.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/ToolReconciler.ts
+var ToolReconciler_exports = /* @__PURE__ */ __exportAll({
+	PreparedToolCallEvidence: () => PreparedToolCallEvidence,
+	ReconciliationCompleted: () => ReconciliationCompleted,
+	ReconciliationDecision: () => ReconciliationDecision,
+	ReconciliationNeverStarted: () => ReconciliationNeverStarted,
+	ReconciliationSafeToRetry: () => ReconciliationSafeToRetry,
+	ReconciliationUncertain: () => ReconciliationUncertain,
+	ToolReconciler: () => ToolReconciler,
+	ToolReconcilerError: () => ToolReconcilerError
+});
+/**
+* Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool
+* Call (durability §10): deterministic identities for supplier-side lookup plus the exact
+* Schema-encoded parameters and their digest. Built from the canonical `ToolCallPrepared` record
+* and the owning Submission's identities — never from in-memory Attempt state.
+*/
+var PreparedToolCallEvidence = class extends Schema.Class("@effect-agent/thread/PreparedToolCallEvidence")({
+	threadId: ThreadId,
+	submissionId: SubmissionId,
+	runId: RunId,
+	turn: ToolCallPrepared.fields.turn,
+	toolCallId: ToolCallId,
+	toolName: ToolCallPrepared.fields.toolName,
+	parameters: PersistedJson,
+	parametersDigest: Digest,
+	executionKind: ToolCallPrepared.fields.executionKind,
+	executionClass: ToolCallPrepared.fields.executionClass,
+	replay: ToolCallPrepared.fields.replay
+}) {};
+/** Proof of nonexecution: resume the original operation or report it unavailable. */
+var ReconciliationNeverStarted = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationNeverStarted")("NeverStarted", {}) {};
+/**
+* Proof that the external execution completed: `result` is the recovered supplier truth, which
+* becomes canonical (`ToolCallSettled` + `ToolCallResolved`) WITHOUT executing anything.
+*/
+var ReconciliationCompleted = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationCompleted")("CompletedWithResult", {
+	result: PersistedJson,
+	isFailure: Schema.Boolean
+}) {};
+/** Only the original operation, identity and parameters may repeat under supported semantics. */
+var ReconciliationSafeToRetry = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationSafeToRetry")("SafeToRetry", {}) {};
+/** No proof either way: the outcome is Unknown and requires authorized resolution (DUR-017). */
+var ReconciliationUncertain = class extends Schema.TaggedClass("@effect-agent/thread/ReconciliationUncertain")("Uncertain", { reason: Schema.String }) {};
+/**
+* What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call
+* (durability §10): execution never started, execution completed with a recoverable result,
+* execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine
+* never invents an external result. Proven nonexecution can close a retired operation with
+* an explicit not-executed result; uncertainty stays parked.
+*/
+const ReconciliationDecision = Schema.Union([
+	ReconciliationNeverStarted,
+	ReconciliationCompleted,
+	ReconciliationSafeToRetry,
+	ReconciliationUncertain
+]);
+/** The reconciliation policy itself failed (supplier unreachable, corrupt lookup, ...). The
+* caller treats this as no proof: the call stays open and the pass may retry. */
+var ToolReconcilerError = class extends Schema.TaggedError()("ToolReconcilerError", {
+	toolCallId: ToolCallId,
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/**
+* Application-registered reconciliation policy consulted by recovery for every open ordinary
+* Tool Call before an Unknown Outcome is recorded (durability §10, DUR-009). A decision is a
+* claim about EXTERNAL truth — typically an idempotency-keyed supplier lookup — never a guess
+* from canonical state alone.
+*
+* `ToolReconciler.uncertain` is the fail-closed default (AGENTS rule 11): with no registered
+* policy, every open call stays Unknown and routes to the authorized DUR-017 resolution path.
+*/
+var ToolReconciler = class extends Context.Service()("@effect-agent/thread/ToolReconciler") {
+	/** Fail-closed default: no proof is ever asserted, every open call stays Unknown. */
+	static uncertain = Layer.succeed(this)({ reconcile: () => Effect.succeed(ReconciliationUncertain.make({ reason: "No reconciliation policy is registered; the outcome stays unknown" })) });
+};
+//#endregion
+export { PreparedToolCallEvidence, ReconciliationCompleted, ReconciliationDecision, ReconciliationNeverStarted, ReconciliationSafeToRetry, ReconciliationUncertain, ToolReconciler, ToolReconcilerError, ToolReconciler_exports as t };
+
+//# sourceMappingURL=ToolReconciler.mjs.map

package/dist/durable/ToolReconciler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolReconciler.mjs","names":[],"sources":["../../src/durable/ToolReconciler.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport { ThreadId, RunId, SubmissionId, ToolCallId } from \"../core/Identifiers.ts\";\nimport { Digest, PersistedJson, ToolCallPrepared } from \"./Records.ts\";\n\n/**\n * Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool\n * Call (durability §10): deterministic identities for supplier-side lookup plus the exact\n * Schema-encoded parameters and their digest. Built from the canonical `ToolCallPrepared` record\n * and the owning Submission's identities — never from in-memory Attempt state.\n */\nexport class PreparedToolCallEvidence extends Schema.Class<PreparedToolCallEvidence>(\n  \"@effect-agent/thread/PreparedToolCallEvidence\",\n)({\n  threadId: ThreadId,\n  submissionId: SubmissionId,\n  runId: RunId,\n  turn: ToolCallPrepared.fields.turn,\n  toolCallId: ToolCallId,\n  toolName: ToolCallPrepared.fields.toolName,\n  parameters: PersistedJson,\n  parametersDigest: Digest,\n  executionKind: ToolCallPrepared.fields.executionKind,\n  executionClass: ToolCallPrepared.fields.executionClass,\n  replay: ToolCallPrepared.fields.replay,\n}) {}\n\n/** Proof of nonexecution: resume the original operation or report it unavailable. */\nexport class ReconciliationNeverStarted extends Schema.TaggedClass<ReconciliationNeverStarted>(\n  \"@effect-agent/thread/ReconciliationNeverStarted\",\n)(\"NeverStarted\", {}) {}\n\n/**\n * Proof that the external execution completed: `result` is the recovered supplier truth, which\n * becomes canonical (`ToolCallSettled` + `ToolCallResolved`) WITHOUT executing anything.\n */\nexport class ReconciliationCompleted extends Schema.TaggedClass<ReconciliationCompleted>(\n  \"@effect-agent/thread/ReconciliationCompleted\",\n)(\"CompletedWithResult\", {\n  result: PersistedJson,\n  isFailure: Schema.Boolean,\n}) {}\n\n/** Only the original operation, identity and parameters may repeat under supported semantics. */\nexport class ReconciliationSafeToRetry extends Schema.TaggedClass<ReconciliationSafeToRetry>(\n  \"@effect-agent/thread/ReconciliationSafeToRetry\",\n)(\"SafeToRetry\", {}) {}\n\n/** No proof either way: the outcome is Unknown and requires authorized resolution (DUR-017). */\nexport class ReconciliationUncertain extends Schema.TaggedClass<ReconciliationUncertain>(\n  \"@effect-agent/thread/ReconciliationUncertain\",\n)(\"Uncertain\", {\n  reason: Schema.String,\n}) {}\n\n/**\n * What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call\n * (durability §10): execution never started, execution completed with a recoverable result,\n * execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine\n * never invents an external result. Proven nonexecution can close a retired operation with\n * an explicit not-executed result; uncertainty stays parked.\n */\nexport const ReconciliationDecision = Schema.Union([\n  ReconciliationNeverStarted,\n  ReconciliationCompleted,\n  ReconciliationSafeToRetry,\n  ReconciliationUncertain,\n]);\n\nexport type ReconciliationDecision = typeof ReconciliationDecision.Type;\n\n/** The reconciliation policy itself failed (supplier unreachable, corrupt lookup, ...). The\n * caller treats this as no proof: the call stays open and the pass may retry. */\nexport class ToolReconcilerError extends Schema.TaggedError<ToolReconcilerError>()(\n  \"ToolReconcilerError\",\n  {\n    toolCallId: ToolCallId,\n    message: Schema.String,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/**\n * Application-registered reconciliation policy consulted by recovery for every open ordinary\n * Tool Call before an Unknown Outcome is recorded (durability §10, DUR-009). A decision is a\n * claim about EXTERNAL truth — typically an idempotency-keyed supplier lookup — never a guess\n * from canonical state alone.\n *\n * `ToolReconciler.uncertain` is the fail-closed default (AGENTS rule 11): with no registered\n * policy, every open call stays Unknown and routes to the authorized DUR-017 resolution path.\n */\nexport class ToolReconciler extends Context.Service<\n  ToolReconciler,\n  {\n    readonly reconcile: (\n      evidence: PreparedToolCallEvidence,\n    ) => Effect.Effect<ReconciliationDecision, ToolReconcilerError>;\n  }\n>()(\"@effect-agent/thread/ToolReconciler\") {\n  /** Fail-closed default: no proof is ever asserted, every open call stays Unknown. */\n  static readonly uncertain: Layer.Layer<ToolReconciler> = Layer.succeed(this)({\n    reconcile: () =>\n      Effect.succeed(\n        ReconciliationUncertain.make({\n          reason: \"No reconciliation policy is registered; the outcome stays unknown\",\n        }),\n      ),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAWA,IAAa,2BAAb,cAA8C,OAAO,MACnD,+CACF,CAAC,CAAC;CACA,UAAU;CACV,cAAc;CACd,OAAO;CACP,MAAM,iBAAiB,OAAO;CAC9B,YAAY;CACZ,UAAU,iBAAiB,OAAO;CAClC,YAAY;CACZ,kBAAkB;CAClB,eAAe,iBAAiB,OAAO;CACvC,gBAAgB,iBAAiB,OAAO;CACxC,QAAQ,iBAAiB,OAAO;AAClC,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,6BAAb,cAAgD,OAAO,YACrD,iDACF,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;;;;;AAMvB,IAAa,0BAAb,cAA6C,OAAO,YAClD,8CACF,CAAC,CAAC,uBAAuB;CACvB,QAAQ;CACR,WAAW,OAAO;AACpB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,4BAAb,cAA+C,OAAO,YACpD,gDACF,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;;AAGtB,IAAa,0BAAb,cAA6C,OAAO,YAClD,8CACF,CAAC,CAAC,aAAa,EACb,QAAQ,OAAO,OACjB,CAAC,CAAC,CAAC,CAAC;;;;;;;;AASJ,MAAa,yBAAyB,OAAO,MAAM;CACjD;CACA;CACA;CACA;AACF,CAAC;;;AAMD,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,YAAY;CACZ,SAAS,OAAO;CAChB,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CACF,CAAC,CAAC,CAAC;;;;;;;;;;AAWH,IAAa,iBAAb,cAAoC,QAAQ,QAO1C,CAAC,CAAC,qCAAqC,CAAC,CAAC;;CAEzC,OAAgB,YAAyC,MAAM,QAAQ,IAAI,CAAC,CAAC,EAC3E,iBACE,OAAO,QACL,wBAAwB,KAAK,EAC3B,QAAQ,oEACV,CAAC,CACH,EACJ,CAAC;AACH"}

package/dist/durable/WakeScheduler.d.mts

@@ -0,0 +1,2 @@
+import { i as makeWakeSubscriptionHub, r as WakeSubscriptionHub, t as WakeScheduler } from "../WakeScheduler-EjUF-GhC.mjs";
+export { WakeScheduler, WakeSubscriptionHub, makeWakeSubscriptionHub };

package/dist/durable/WakeScheduler.mjs

@@ -0,0 +1,85 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Deferred, Effect, Layer, Ref, Stream } from "effect";
+//#region src/durable/WakeScheduler.ts
+var WakeScheduler_exports = /* @__PURE__ */ __exportAll({
+	WakeScheduler: () => WakeScheduler,
+	makeWakeSubscriptionHub: () => makeWakeSubscriptionHub
+});
+/**
+* Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub
+* contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and
+* rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts
+* instead of consuming a signal that belongs to another waiter.
+*/
+const makeWakeSubscriptionHub = Effect.gen(function* () {
+	const registrations = yield* Ref.make(/* @__PURE__ */ new Map());
+	const nextId = yield* Ref.make(0);
+	const remove = (threadId, id) => Ref.update(registrations, (current) => {
+		const existing = current.get(threadId);
+		if (existing === void 0 || !existing.has(id)) return current;
+		const next = new Map(current);
+		const thread = new Map(existing);
+		thread.delete(id);
+		if (thread.size === 0) next.delete(threadId);
+		else next.set(threadId, thread);
+		return next;
+	});
+	return {
+		subscribe: Effect.fn("WakeSubscriptionHub.subscribe")((threadId) => Effect.gen(function* () {
+			const deferred = yield* Deferred.make();
+			const registration = {
+				id: yield* Ref.getAndUpdate(nextId, (current) => current + 1),
+				deferred
+			};
+			yield* Effect.addFinalizer(() => remove(threadId, registration.id));
+			yield* Ref.update(registrations, (current) => {
+				const next = new Map(current);
+				const thread = new Map(current.get(threadId) ?? []);
+				thread.set(registration.id, registration.deferred);
+				next.set(threadId, thread);
+				return next;
+			});
+			return registration.deferred;
+		}).pipe(Effect.map((deferred) => Deferred.await(deferred)))),
+		notify: Effect.fn("WakeSubscriptionHub.notify")(function* (threadId) {
+			const waiters = yield* Ref.modify(registrations, (current) => {
+				const thread = current.get(threadId);
+				if (thread === void 0) return [[], current];
+				const next = new Map(current);
+				next.delete(threadId);
+				return [[...thread.values()], next];
+			});
+			yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, void 0), { discard: true });
+		})
+	};
+});
+/**
+* Liveness hint channel for durable schedulers. `notify` announces that a Thread lane may
+* have claimable, canonical, or settled work; `wakes` is the all-lanes subscription surface for
+* workers, while `subscribe` installs an efficient one-Thread wait registration.
+*
+* Correctness must NEVER depend on delivery: notifications may be dropped, coalesced, duplicated,
+* or observed by no subscriber (a notify before any subscription is simply lost). Every consumer
+* must pair a wake with durable authority: workers use periodic SubmissionLedger scans, while a
+* public progress waiter subscribes before its canonical read and reconnects/rechecks after an
+* incarnation loss (persistence §14).
+*
+* Each run of `wakes` creates its own subscription whose resources live in that run's Scope and
+* are released when the consuming stream ends or is interrupted. Implementations must not spawn
+* daemon fibers.
+*/
+var WakeScheduler = class WakeScheduler extends Context.Service()("@effect-agent/thread/WakeScheduler") {
+	/**
+	* Discards every notification and never wakes anyone. Valid because WakeScheduler is only a
+	* liveness hint: consumers relying on ledger scans stay correct, merely slower.
+	*/
+	static layerNoop = Layer.succeed(WakeScheduler, {
+		notify: () => Effect.void,
+		subscribe: () => Effect.succeed(Effect.never),
+		wakes: Stream.never
+	});
+};
+//#endregion
+export { WakeScheduler, makeWakeSubscriptionHub, WakeScheduler_exports as t };
+
+//# sourceMappingURL=WakeScheduler.mjs.map

package/dist/durable/WakeScheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WakeScheduler.mjs","names":[],"sources":["../../src/durable/WakeScheduler.ts"],"sourcesContent":["import type { Scope } from \"effect\";\nimport { Context, Deferred, Effect, Layer, Ref, Stream } from \"effect\";\n\nimport { type ThreadId } from \"../core/Identifiers.ts\";\n\n/**\n * Incarnation-local, thread-keyed wake registrations. A registration is installed before\n * its returned Effect can be awaited, which lets a caller subscribe, check durable authority,\n * and then park without a lost-wakeup window.\n */\nexport interface WakeSubscriptionHub {\n  /** Register one Scope-owned waiter and return its one-shot wake Effect. */\n  readonly subscribe: (\n    threadId: ThreadId,\n  ) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;\n  /** Wake every currently registered waiter for exactly this Thread. */\n  readonly notify: (threadId: ThreadId) => Effect.Effect<void>;\n}\n\ninterface WakeRegistration {\n  readonly id: number;\n  readonly deferred: Deferred.Deferred<void>;\n}\n\ntype WakeRegistrations = ReadonlyMap<ThreadId, ReadonlyMap<number, Deferred.Deferred<void>>>;\n\n/**\n * Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub\n * contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and\n * rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts\n * instead of consuming a signal that belongs to another waiter.\n */\nexport const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.gen(function* () {\n  const registrations = yield* Ref.make<WakeRegistrations>(new Map());\n  const nextId = yield* Ref.make(0);\n\n  const remove = (threadId: ThreadId, id: number) =>\n    Ref.update(registrations, (current) => {\n      const existing = current.get(threadId);\n\n      if (existing === undefined || !existing.has(id)) return current;\n      const next = new Map(current);\n      const thread = new Map(existing);\n\n      thread.delete(id);\n      if (thread.size === 0) {\n        next.delete(threadId);\n      } else {\n        next.set(threadId, thread);\n      }\n\n      return next;\n    });\n\n  const subscribe = Effect.fn(\"WakeSubscriptionHub.subscribe\")(\n    (threadId: ThreadId): Effect.Effect<Effect.Effect<void>, never, Scope.Scope> =>\n      Effect.gen(function* () {\n        const deferred = yield* Deferred.make<void>();\n        const id = yield* Ref.getAndUpdate(nextId, (current) => current + 1);\n        const registration: WakeRegistration = { id, deferred };\n\n        yield* Effect.addFinalizer(() => remove(threadId, registration.id));\n        yield* Ref.update(registrations, (current) => {\n          const next = new Map(current);\n          const thread = new Map(current.get(threadId) ?? []);\n\n          thread.set(registration.id, registration.deferred);\n          next.set(threadId, thread);\n\n          return next;\n        });\n\n        return registration.deferred;\n      }).pipe(Effect.map((deferred) => Deferred.await(deferred))),\n  );\n\n  const notify = Effect.fn(\"WakeSubscriptionHub.notify\")(function* (threadId: ThreadId) {\n    const waiters = yield* Ref.modify(registrations, (current) => {\n      const thread = current.get(threadId);\n\n      if (thread === undefined) return [[], current] as const;\n      const next = new Map(current);\n\n      next.delete(threadId);\n\n      return [[...thread.values()], next] as const;\n    });\n\n    yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, undefined), {\n      discard: true,\n    });\n  });\n\n  return { subscribe, notify };\n});\n\n/**\n * Liveness hint channel for durable schedulers. `notify` announces that a Thread lane may\n * have claimable, canonical, or settled work; `wakes` is the all-lanes subscription surface for\n * workers, while `subscribe` installs an efficient one-Thread wait registration.\n *\n * Correctness must NEVER depend on delivery: notifications may be dropped, coalesced, duplicated,\n * or observed by no subscriber (a notify before any subscription is simply lost). Every consumer\n * must pair a wake with durable authority: workers use periodic SubmissionLedger scans, while a\n * public progress waiter subscribes before its canonical read and reconnects/rechecks after an\n * incarnation loss (persistence §14).\n *\n * Each run of `wakes` creates its own subscription whose resources live in that run's Scope and\n * are released when the consuming stream ends or is interrupted. Implementations must not spawn\n * daemon fibers.\n */\nexport class WakeScheduler extends Context.Service<\n  WakeScheduler,\n  {\n    /** Best-effort hint that `threadId` may have claimable or settled work. Never fails. */\n    readonly notify: (threadId: ThreadId) => Effect.Effect<void>;\n    /** Scope-owned one-shot registration for exactly one Thread. */\n    readonly subscribe: (\n      threadId: ThreadId,\n    ) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;\n    /** Scope-owned subscription to wake hints, starting at subscription time. */\n    readonly wakes: Stream.Stream<ThreadId>;\n  }\n>()(\"@effect-agent/thread/WakeScheduler\") {\n  /**\n   * Discards every notification and never wakes anyone. Valid because WakeScheduler is only a\n   * liveness hint: consumers relying on ledger scans stay correct, merely slower.\n   */\n  static readonly layerNoop: Layer.Layer<WakeScheduler> = Layer.succeed(WakeScheduler, {\n    notify: () => Effect.void,\n    subscribe: () => Effect.succeed(Effect.never),\n    wakes: Stream.never,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAgCA,MAAa,0BAA8D,OAAO,IAAI,aAAa;CACjG,MAAM,gBAAgB,OAAO,IAAI,qBAAwB,IAAI,IAAI,CAAC;CAClE,MAAM,SAAS,OAAO,IAAI,KAAK,CAAC;CAEhC,MAAM,UAAU,UAAoB,OAClC,IAAI,OAAO,gBAAgB,YAAY;EACrC,MAAM,WAAW,QAAQ,IAAI,QAAQ;EAErC,IAAI,aAAa,KAAA,KAAa,CAAC,SAAS,IAAI,EAAE,GAAG,OAAO;EACxD,MAAM,OAAO,IAAI,IAAI,OAAO;EAC5B,MAAM,SAAS,IAAI,IAAI,QAAQ;EAE/B,OAAO,OAAO,EAAE;EAChB,IAAI,OAAO,SAAS,GAClB,KAAK,OAAO,QAAQ;OAEpB,KAAK,IAAI,UAAU,MAAM;EAG3B,OAAO;CACT,CAAC;CAyCH,OAAO;EAAE,WAvCS,OAAO,GAAG,+BAA+B,CAAC,EACzD,aACC,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,SAAS,KAAW;GAE5C,MAAM,eAAiC;IAAE,IAAA,OADvB,IAAI,aAAa,SAAS,YAAY,UAAU,CAAC;IACtB;GAAS;GAEtD,OAAO,OAAO,mBAAmB,OAAO,UAAU,aAAa,EAAE,CAAC;GAClE,OAAO,IAAI,OAAO,gBAAgB,YAAY;IAC5C,MAAM,OAAO,IAAI,IAAI,OAAO;IAC5B,MAAM,SAAS,IAAI,IAAI,QAAQ,IAAI,QAAQ,KAAK,CAAC,CAAC;IAElD,OAAO,IAAI,aAAa,IAAI,aAAa,QAAQ;IACjD,KAAK,IAAI,UAAU,MAAM;IAEzB,OAAO;GACT,CAAC;GAED,OAAO,aAAa;EACtB,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,aAAa,SAAS,MAAM,QAAQ,CAAC,CAAC,CAoB7C;EAAG,QAjBL,OAAO,GAAG,4BAA4B,CAAC,CAAC,WAAW,UAAoB;GACpF,MAAM,UAAU,OAAO,IAAI,OAAO,gBAAgB,YAAY;IAC5D,MAAM,SAAS,QAAQ,IAAI,QAAQ;IAEnC,IAAI,WAAW,KAAA,GAAW,OAAO,CAAC,CAAC,GAAG,OAAO;IAC7C,MAAM,OAAO,IAAI,IAAI,OAAO;IAE5B,KAAK,OAAO,QAAQ;IAEpB,OAAO,CAAC,CAAC,GAAG,OAAO,OAAO,CAAC,GAAG,IAAI;GACpC,CAAC;GAED,OAAO,OAAO,QAAQ,UAAU,WAAW,SAAS,QAAQ,QAAQ,KAAA,CAAS,GAAG,EAC9E,SAAS,KACX,CAAC;EACH,CAEyB;CAAE;AAC7B,CAAC;;;;;;;;;;;;;;;;AAiBD,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,QAYzC,CAAC,CAAC,oCAAoC,CAAC,CAAC;;;;;CAKxC,OAAgB,YAAwC,MAAM,QAAQ,eAAe;EACnF,cAAc,OAAO;EACrB,iBAAiB,OAAO,QAAQ,OAAO,KAAK;EAC5C,OAAO,OAAO;CAChB,CAAC;AACH"}

package/dist/durable/WorkerHost.d.mts

@@ -0,0 +1,129 @@
+import { l as SubmissionId, u as ThreadId } from "../Identifiers-CN2s30fF.mjs";
+import { i as SubagentBudgetReservation } from "../SubagentContract-DdT7Cqe6.mjs";
+import { r as Principal } from "../Receipt-BAHyigAF.mjs";
+import { t as AgentPolicy } from "../AgentPolicy-BqDoSXO6.mjs";
+import { r as AnyDefinition, t as Agent_d_exports } from "../Agent-D9cXqfF3.mjs";
+import { c as WorkerError, f as WorkerRef, h as WorkerSource } from "../Worker-fwWkBg12.mjs";
+import { O as PersistedJson, _ as Digest, dt as WorkerOrigin, h as DefinitionDigests, ko as SubmissionSnapshot } from "../Records-D88mgvyS.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+declare namespace WorkerHost_d_exports {
+  export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizationRequest, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerPolicySource, WorkerPolicyTarget };
+}
+/** Host-verified source input; absence never means the latest input in the Thread. */
+export interface WorkerPolicySource {
+  readonly threadId: ThreadId;
+  readonly definition: AnyDefinition;
+  readonly definitions: DefinitionDigests;
+  readonly submission?: SubmissionSnapshot;
+}
+/** Initial input is validated again at destination admission, including idempotent replay. */
+export type WorkerPolicyTarget = {
+  readonly definition: AnyDefinition;
+  readonly definitions: DefinitionDigests;
+  readonly source: WorkerSource;
+} & ({
+  readonly _tag: "InitialInput";
+  readonly sourceSubmission?: SubmissionSnapshot;
+  readonly input: PersistedJson;
+  readonly inputDigest: Digest;
+} | {
+  readonly _tag: "RetainedWorker";
+  /** Verified against canonical source history before this request reaches the resolver. */
+  readonly origin: WorkerOrigin;
+});
+/**
+ * Opt-in host authority for policies captured in immutable application input. None preserves
+ * the registered Definition's existing policy/override semantics. Some is a complete policy,
+ * never merged with static overrides. Decode and authorize the exact captured revision; do not
+ * read mutable settings or substitute a current capture for missing historical authority.
+ * RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.
+ * Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.
+ * Implementations are acquired through Effect Layers; capture their dependencies in Layer R.
+ */
+export declare const WorkerPolicyResolver: Context.Reference<{
+  readonly resolveSource: (request: WorkerPolicySource) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+  readonly resolveTarget: (request: WorkerPolicyTarget) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;
+}>;
+/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */
+export declare const WorkerConcurrencyLimit: Schema.Struct<{
+  readonly maxActiveWorkersPerSource: Schema.Int;
+}>;
+export type WorkerConcurrencyLimit = typeof WorkerConcurrencyLimit.Type;
+/**
+ * Optional source-aware operational authority. Resolution occurs inside every new source
+ * reservation attempt, against the same canonical history used for the append CAS. None
+ * preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,
+ * never the latest input. Implementations must authorize that immutable capture and retain
+ * construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).
+ *
+ * One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active
+ * worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;
+ * an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.
+ */
+export declare const WorkerConcurrencyResolver: Context.Reference<{
+  readonly resolve: (request: {
+    readonly source: WorkerSource;
+    readonly sourceSubmission?: SubmissionSnapshot;
+    readonly worker: WorkerRef;
+    readonly principal: Principal;
+  }) => Effect.Effect<Option.Option<WorkerConcurrencyLimit>, WorkerError>;
+}>;
+/** Host ceilings apply across all declarations owned by one source Thread. */
+export declare const WorkerHostLimits: Schema.Struct<{
+  readonly maxWorkersPerSource: Schema.Int;
+  /** Active background workers across declarations; omission retains source Tool concurrency. */
+  readonly maxActiveWorkersPerSource: Schema.optionalKey<Schema.Int>;
+  readonly maxInputsPerWorker: Schema.Int;
+  readonly maxPendingInputsPerWorker: Schema.Int;
+  readonly maxUpdateInputsPerWorker: Schema.optionalKey<Schema.Int>;
+  readonly maxPendingUpdateInputsPerWorker: Schema.optionalKey<Schema.Int>;
+  readonly lifetimeMillis: Schema.Int;
+  /** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */
+  readonly reportPreparationTimeoutMillis: Schema.optionalKey<Schema.Int>;
+}>;
+export type WorkerHostLimits = typeof WorkerHostLimits.Type;
+export declare const WorkerHostConfig: Context.Reference<{
+  readonly maxWorkersPerSource: number;
+  readonly maxActiveWorkersPerSource?: number | undefined;
+  readonly maxInputsPerWorker: number;
+  readonly maxPendingInputsPerWorker: number;
+  readonly maxUpdateInputsPerWorker?: number | undefined;
+  readonly maxPendingUpdateInputsPerWorker?: number | undefined;
+  readonly lifetimeMillis: number;
+  readonly reportPreparationTimeoutMillis?: number | undefined;
+}>;
+/**
+ * Authenticate every acquisition/operation and authorize its exact source Thread. A returned
+ * Principal is host-owned admission identity. Context access authenticates source metadata;
+ * read, send and control remain separate grants. WorkerRefs and caller-supplied Thread
+ * identifiers alone never confer any of them.
+ */
+export interface WorkerHostAuthorizationRequest {
+  readonly sourceThreadId: ThreadId;
+  /** An explicitly selected owner input; authorize this locator as well as the Thread. */
+  readonly sourceSubmissionId?: SubmissionId;
+  readonly principal: Principal;
+  readonly operation: WorkerError["operation"];
+  readonly access: "context" | "read" | "send" | "control";
+  readonly worker?: WorkerRef;
+}
+export declare const WorkerHostAuthorizer: Context.Reference<{
+  readonly authorize: (request: WorkerHostAuthorizationRequest) => Effect.Effect<Principal, WorkerError>;
+}>;
+/**
+ * Deployment-owned permission to fund a root's background worker independently. The decision
+ * covers the exact immutable origin and is checked again before each input admission. It never
+ * changes delegation depth or Tool authority. Omission denies independent funding.
+ */
+export declare const WorkerBudgetAuthorizer: Context.Reference<{
+  readonly authorize: (request: {
+    readonly source: WorkerSource;
+    readonly principal: Principal;
+    readonly worker: WorkerRef;
+    readonly policy: AgentPolicy;
+    readonly budget: SubagentBudgetReservation;
+  }) => Effect.Effect<void, WorkerError>;
+}>;
+//#endregion
+export { WorkerHost_d_exports as t };
+//# sourceMappingURL=WorkerHost.d.mts.map

package/dist/durable/WorkerHost.mjs

@@ -0,0 +1,77 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { c as WorkerError } from "../Worker-CfwzMZEK.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+//#region src/durable/WorkerHost.ts
+var WorkerHost_exports = /* @__PURE__ */ __exportAll({
+	WorkerBudgetAuthorizer: () => WorkerBudgetAuthorizer,
+	WorkerConcurrencyLimit: () => WorkerConcurrencyLimit,
+	WorkerConcurrencyResolver: () => WorkerConcurrencyResolver,
+	WorkerHostAuthorizer: () => WorkerHostAuthorizer,
+	WorkerHostConfig: () => WorkerHostConfig,
+	WorkerHostLimits: () => WorkerHostLimits,
+	WorkerPolicyResolver: () => WorkerPolicyResolver
+});
+/**
+* Opt-in host authority for policies captured in immutable application input. None preserves
+* the registered Definition's existing policy/override semantics. Some is a complete policy,
+* never merged with static overrides. Decode and authorize the exact captured revision; do not
+* read mutable settings or substitute a current capture for missing historical authority.
+* RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.
+* Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.
+* Implementations are acquired through Effect Layers; capture their dependencies in Layer R.
+*/
+const WorkerPolicyResolver = Context.Reference("@effect-agent/thread/WorkerPolicyResolver", { defaultValue: () => ({
+	resolveSource: () => Effect.succeed(Option.none()),
+	resolveTarget: () => Effect.succeed(Option.none())
+}) });
+const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */
+const WorkerConcurrencyLimit = Schema.Struct({ maxActiveWorkersPerSource: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) });
+/**
+* Optional source-aware operational authority. Resolution occurs inside every new source
+* reservation attempt, against the same canonical history used for the append CAS. None
+* preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,
+* never the latest input. Implementations must authorize that immutable capture and retain
+* construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).
+*
+* One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active
+* worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;
+* an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.
+*/
+const WorkerConcurrencyResolver = Context.Reference("@effect-agent/thread/WorkerConcurrencyResolver", { defaultValue: () => ({ resolve: () => Effect.succeed(Option.none()) }) });
+/** Host ceilings apply across all declarations owned by one source Thread. */
+const WorkerHostLimits = Schema.Struct({
+	maxWorkersPerSource: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	/** Active background workers across declarations; omission retains source Tool concurrency. */
+	maxActiveWorkersPerSource: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),
+	maxInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(1e3)),
+	maxPendingInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(100)),
+	maxUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(1e3))),
+	maxPendingUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),
+	lifetimeMillis: Positive.check(Schema.isLessThanOrEqualTo(6048e5)),
+	/** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */
+	reportPreparationTimeoutMillis: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(3e4)))
+});
+const WorkerHostConfig = Context.Reference("@effect-agent/thread/WorkerHostConfig", { defaultValue: () => ({
+	maxWorkersPerSource: 32,
+	maxInputsPerWorker: 64,
+	maxPendingInputsPerWorker: 8,
+	lifetimeMillis: 864e5
+}) });
+const WorkerHostAuthorizer = Context.Reference("@effect-agent/thread/WorkerHostAuthorizer", { defaultValue: () => ({ authorize: (request) => WorkerError.make({
+	operation: request.operation,
+	reason: "denied"
+}) }) });
+/**
+* Deployment-owned permission to fund a root's background worker independently. The decision
+* covers the exact immutable origin and is checked again before each input admission. It never
+* changes delegation depth or Tool authority. Omission denies independent funding.
+*/
+const WorkerBudgetAuthorizer = Context.Reference("@effect-agent/thread/WorkerBudgetAuthorizer", { defaultValue: () => ({ authorize: () => WorkerError.make({
+	operation: "start",
+	reason: "denied"
+}) }) });
+//#endregion
+export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerHost_exports as t };
+
+//# sourceMappingURL=WorkerHost.mjs.map

package/dist/durable/WorkerHost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerHost.mjs","names":[],"sources":["../../src/durable/WorkerHost.ts"],"sourcesContent":["import { Context, Effect, Option, Schema } from \"effect\";\n\nimport type * as Agent from \"../core/Agent.ts\";\nimport type { AgentPolicy } from \"../core/AgentPolicy.ts\";\nimport type { SubmissionId, ThreadId } from \"../core/Identifiers.ts\";\nimport type { SubagentBudgetReservation } from \"../core/SubagentContract.ts\";\nimport { WorkerError, type WorkerRef, type WorkerSource } from \"../core/Worker.ts\";\nimport type { DefinitionDigests, Digest, PersistedJson, WorkerOrigin } from \"./Records.ts\";\nimport type { Principal, SubmissionSnapshot } from \"./SubmissionLedger.ts\";\n\n/** Host-verified source input; absence never means the latest input in the Thread. */\nexport interface WorkerPolicySource {\n  readonly threadId: ThreadId;\n  readonly definition: Agent.AnyDefinition;\n  readonly definitions: DefinitionDigests;\n  readonly submission?: SubmissionSnapshot;\n}\n\n/** Initial input is validated again at destination admission, including idempotent replay. */\nexport type WorkerPolicyTarget = {\n  readonly definition: Agent.AnyDefinition;\n  readonly definitions: DefinitionDigests;\n  readonly source: WorkerSource;\n} & (\n  | {\n      readonly _tag: \"InitialInput\";\n      readonly sourceSubmission?: SubmissionSnapshot;\n      readonly input: PersistedJson;\n      readonly inputDigest: Digest;\n    }\n  | {\n      readonly _tag: \"RetainedWorker\";\n      /** Verified against canonical source history before this request reaches the resolver. */\n      readonly origin: WorkerOrigin;\n    }\n);\n\n/**\n * Opt-in host authority for policies captured in immutable application input. None preserves\n * the registered Definition's existing policy/override semantics. Some is a complete policy,\n * never merged with static overrides. Decode and authorize the exact captured revision; do not\n * read mutable settings or substitute a current capture for missing historical authority.\n * RetainedWorker may affirm only origin.policy, never replace a continuing worker's allowance.\n * Return WorkerError(unavailable) for temporarily unavailable authority so delivery can retry.\n * Implementations are acquired through Effect Layers; capture their dependencies in Layer R.\n */\nexport const WorkerPolicyResolver = Context.Reference<{\n  readonly resolveSource: (\n    request: WorkerPolicySource,\n  ) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;\n  readonly resolveTarget: (\n    request: WorkerPolicyTarget,\n  ) => Effect.Effect<Option.Option<AgentPolicy>, WorkerError>;\n}>(\"@effect-agent/thread/WorkerPolicyResolver\", {\n  defaultValue: () => ({\n    resolveSource: () => Effect.succeed(Option.none()),\n    resolveTarget: () => Effect.succeed(Option.none()),\n  }),\n});\n\nconst Positive = Schema.Int.check(Schema.isGreaterThan(0));\n\n/** A host-authorized ceiling on active background workers, not retained workers or Run usage. */\nexport const WorkerConcurrencyLimit = Schema.Struct({\n  maxActiveWorkersPerSource: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n});\n\nexport type WorkerConcurrencyLimit = typeof WorkerConcurrencyLimit.Type;\n\n/**\n * Optional source-aware operational authority. Resolution occurs inside every new source\n * reservation attempt, against the same canonical history used for the append CAS. None\n * preserves WorkerHostConfig; Some can only narrow it. The selected submission is exact,\n * never the latest input. Implementations must authorize that immutable capture and retain\n * construction dependencies in Layer R. Unavailable authority must return WorkerError(unavailable).\n *\n * One worker occupies a slot while any of its inputs remain unacknowledged. Steering an active\n * worker does not acquire another slot. Decreases (including zero) do not cancel incumbents;\n * an idle worker needs a slot again. Idempotent retained reservations do not reacquire slots.\n */\nexport const WorkerConcurrencyResolver = Context.Reference<{\n  readonly resolve: (request: {\n    readonly source: WorkerSource;\n    readonly sourceSubmission?: SubmissionSnapshot;\n    readonly worker: WorkerRef;\n    readonly principal: Principal;\n  }) => Effect.Effect<Option.Option<WorkerConcurrencyLimit>, WorkerError>;\n}>(\"@effect-agent/thread/WorkerConcurrencyResolver\", {\n  defaultValue: () => ({ resolve: () => Effect.succeed(Option.none()) }),\n});\n\n/** Host ceilings apply across all declarations owned by one source Thread. */\nexport const WorkerHostLimits = Schema.Struct({\n  maxWorkersPerSource: Positive.check(Schema.isLessThanOrEqualTo(100)),\n  /** Active background workers across declarations; omission retains source Tool concurrency. */\n  maxActiveWorkersPerSource: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(100))),\n  maxInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(1_000)),\n  maxPendingInputsPerWorker: Positive.check(Schema.isLessThanOrEqualTo(100)),\n  maxUpdateInputsPerWorker: Schema.optionalKey(Positive.check(Schema.isLessThanOrEqualTo(1_000))),\n  maxPendingUpdateInputsPerWorker: Schema.optionalKey(\n    Positive.check(Schema.isLessThanOrEqualTo(100)),\n  ),\n  lifetimeMillis: Positive.check(Schema.isLessThanOrEqualTo(604_800_000)),\n  /** Preparation may repeat after loss before its decision commits; keep callbacks side-effect free. */\n  reportPreparationTimeoutMillis: Schema.optionalKey(\n    Positive.check(Schema.isLessThanOrEqualTo(30_000)),\n  ),\n});\n\nexport type WorkerHostLimits = typeof WorkerHostLimits.Type;\n\nexport const WorkerHostConfig = Context.Reference<WorkerHostLimits>(\n  \"@effect-agent/thread/WorkerHostConfig\",\n  {\n    defaultValue: () => ({\n      maxWorkersPerSource: 32,\n      maxInputsPerWorker: 64,\n      maxPendingInputsPerWorker: 8,\n      lifetimeMillis: 86_400_000,\n    }),\n  },\n);\n\n/**\n * Authenticate every acquisition/operation and authorize its exact source Thread. A returned\n * Principal is host-owned admission identity. Context access authenticates source metadata;\n * read, send and control remain separate grants. WorkerRefs and caller-supplied Thread\n * identifiers alone never confer any of them.\n */\nexport interface WorkerHostAuthorizationRequest {\n  readonly sourceThreadId: ThreadId;\n  /** An explicitly selected owner input; authorize this locator as well as the Thread. */\n  readonly sourceSubmissionId?: SubmissionId;\n  readonly principal: Principal;\n  readonly operation: WorkerError[\"operation\"];\n  readonly access: \"context\" | \"read\" | \"send\" | \"control\";\n  readonly worker?: WorkerRef;\n}\n\nexport const WorkerHostAuthorizer = Context.Reference<{\n  readonly authorize: (\n    request: WorkerHostAuthorizationRequest,\n  ) => Effect.Effect<Principal, WorkerError>;\n}>(\"@effect-agent/thread/WorkerHostAuthorizer\", {\n  defaultValue: () => ({\n    authorize: (request) =>\n      WorkerError.make({\n        operation: request.operation,\n        reason: \"denied\",\n      }),\n  }),\n});\n\n/**\n * Deployment-owned permission to fund a root's background worker independently. The decision\n * covers the exact immutable origin and is checked again before each input admission. It never\n * changes delegation depth or Tool authority. Omission denies independent funding.\n */\nexport const WorkerBudgetAuthorizer = Context.Reference<{\n  readonly authorize: (request: {\n    readonly source: WorkerSource;\n    readonly principal: Principal;\n    readonly worker: WorkerRef;\n    readonly policy: AgentPolicy;\n    readonly budget: SubagentBudgetReservation;\n  }) => Effect.Effect<void, WorkerError>;\n}>(\"@effect-agent/thread/WorkerBudgetAuthorizer\", {\n  defaultValue: () => ({\n    authorize: () => WorkerError.make({ operation: \"start\", reason: \"denied\" }),\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA8CA,MAAa,uBAAuB,QAAQ,UAOzC,6CAA6C,EAC9C,qBAAqB;CACnB,qBAAqB,OAAO,QAAQ,OAAO,KAAK,CAAC;CACjD,qBAAqB,OAAO,QAAQ,OAAO,KAAK,CAAC;AACnD,GACF,CAAC;AAED,MAAM,WAAW,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;;AAGzD,MAAa,yBAAyB,OAAO,OAAO,EAClD,2BAA2B,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC,EAC9E,CAAC;;;;;;;;;;;;AAeD,MAAa,4BAA4B,QAAQ,UAO9C,kDAAkD,EACnD,qBAAqB,EAAE,eAAe,OAAO,QAAQ,OAAO,KAAK,CAAC,EAAE,GACtE,CAAC;;AAGD,MAAa,mBAAmB,OAAO,OAAO;CAC5C,qBAAqB,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC;;CAEnE,2BAA2B,OAAO,YAAY,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC,CAAC;CAC7F,oBAAoB,SAAS,MAAM,OAAO,oBAAoB,GAAK,CAAC;CACpE,2BAA2B,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC;CACzE,0BAA0B,OAAO,YAAY,SAAS,MAAM,OAAO,oBAAoB,GAAK,CAAC,CAAC;CAC9F,iCAAiC,OAAO,YACtC,SAAS,MAAM,OAAO,oBAAoB,GAAG,CAAC,CAChD;CACA,gBAAgB,SAAS,MAAM,OAAO,oBAAoB,MAAW,CAAC;;CAEtE,gCAAgC,OAAO,YACrC,SAAS,MAAM,OAAO,oBAAoB,GAAM,CAAC,CACnD;AACF,CAAC;AAID,MAAa,mBAAmB,QAAQ,UACtC,yCACA,EACE,qBAAqB;CACnB,qBAAqB;CACrB,oBAAoB;CACpB,2BAA2B;CAC3B,gBAAgB;AAClB,GACF,CACF;AAkBA,MAAa,uBAAuB,QAAQ,UAIzC,6CAA6C,EAC9C,qBAAqB,EACnB,YAAY,YACV,YAAY,KAAK;CACf,WAAW,QAAQ;CACnB,QAAQ;AACV,CAAC,EACL,GACF,CAAC;;;;;;AAOD,MAAa,yBAAyB,QAAQ,UAQ3C,+CAA+C,EAChD,qBAAqB,EACnB,iBAAiB,YAAY,KAAK;CAAE,WAAW;CAAS,QAAQ;AAAS,CAAC,EAC5E,GACF,CAAC"}

package/dist/engine/AgentRuntime.d.mts

@@ -0,0 +1,2 @@
+import { A as start, C as decodeFinalOutput, D as renderInputPrompt, E as projectCompletionOutput, F as withTerminalDefectEvent, M as stream, N as streamUnknown, O as run, P as streamWithUsageAccountingUnknown, S as ToolCallWaiting, T as projectCompletionFromToolOutput, _ as SubagentDurability, a as AgentResultSchema, b as SubagentDurabilityError, c as AgentSpawner, d as DetachedRun, f as EngineProvidedToolServices, g as SpawnedChildRun, h as SpawnRunOptions, i as AgentResult, j as startUnknown, k as runUnknown, l as AgentSpawnerParent, m as SpawnDelegation, n as AgentChildPending, o as AgentRuntimeFailure, p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements, u as AgentSpawnerService, v as SubagentDurabilityDurable, w as encodeRunDisposition, x as SubagentDurabilityService, y as SubagentDurabilityEphemeral } from "../AgentRuntime-BUxDdLpw.mjs";
+export { AgentChildPending, type AgentCompletionProjectionRequirements, type AgentResult, AgentResultSchema, type AgentRuntimeFailure, type AgentRuntimeRequirements, AgentSpawner, type AgentSpawnerParent, type AgentSpawnerService, type DetachedRun, type EngineProvidedToolServices, type RuntimeBinding, type SpawnDelegation, type SpawnRunOptions, type SpawnedChildRun, SubagentDurability, type SubagentDurabilityDurable, type SubagentDurabilityEphemeral, SubagentDurabilityError, type SubagentDurabilityService, ToolCallWaiting, decodeFinalOutput, encodeRunDisposition, projectCompletionFromToolOutput, projectCompletionOutput, renderInputPrompt, run, runUnknown, start, startUnknown, stream, streamUnknown, streamWithUsageAccountingUnknown, withTerminalDefectEvent };

package/dist/engine/AgentRuntime.mjs

@@ -0,0 +1,2 @@
+import { _ as stream, a as SubagentDurability, b as withTerminalDefectEvent, c as decodeFinalOutput, d as projectCompletionOutput, f as renderInputPrompt, g as startUnknown, h as start, i as AgentSpawner, l as encodeRunDisposition, m as runUnknown, n as AgentChildPending, o as SubagentDurabilityError, p as run, r as AgentResultSchema, s as ToolCallWaiting, u as projectCompletionFromToolOutput, v as streamUnknown, y as streamWithUsageAccountingUnknown } from "../AgentRuntime-Cp1hAb-W.mjs";
+export { AgentChildPending, AgentResultSchema, AgentSpawner, SubagentDurability, SubagentDurabilityError, ToolCallWaiting, decodeFinalOutput, encodeRunDisposition, projectCompletionFromToolOutput, projectCompletionOutput, renderInputPrompt, run, runUnknown, start, startUnknown, stream, streamUnknown, streamWithUsageAccountingUnknown, withTerminalDefectEvent };

package/dist/engine/Compaction.d.mts

@@ -0,0 +1,7 @@
+import { d as CONTEXT_ROLLOVER_PREFIX, f as ContextCompactionState, g as estimatePromptTokens, h as estimateMessageTokens, l as CLEARED_TOOL_RESULT, m as contextWindowMessage, p as contextWindowId, u as COMPACTION_SUMMARY_PREFIX } from "../ContextCompactor-WwSIG_Z2.mjs";
+declare namespace Compaction_d_exports {
+  export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, ContextCompactionState, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens };
+}
+//#endregion
+export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, type ContextCompactionState, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens, Compaction_d_exports as t };
+//# sourceMappingURL=Compaction.d.mts.map

package/dist/engine/Compaction.mjs

@@ -0,0 +1,16 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { f as contextWindowId, h as estimatePromptTokens, m as estimateMessageTokens, n as COMPACTION_SUMMARY_PREFIX, p as contextWindowMessage, r as CONTEXT_ROLLOVER_PREFIX, t as CLEARED_TOOL_RESULT } from "../compaction-C2OTceKw.mjs";
+//#region src/engine/Compaction.ts
+var Compaction_exports = /* @__PURE__ */ __exportAll({
+	CLEARED_TOOL_RESULT: () => CLEARED_TOOL_RESULT,
+	COMPACTION_SUMMARY_PREFIX: () => COMPACTION_SUMMARY_PREFIX,
+	CONTEXT_ROLLOVER_PREFIX: () => CONTEXT_ROLLOVER_PREFIX,
+	contextWindowId: () => contextWindowId,
+	contextWindowMessage: () => contextWindowMessage,
+	estimateMessageTokens: () => estimateMessageTokens,
+	estimatePromptTokens: () => estimatePromptTokens
+});
+//#endregion
+export { CLEARED_TOOL_RESULT, COMPACTION_SUMMARY_PREFIX, CONTEXT_ROLLOVER_PREFIX, contextWindowId, contextWindowMessage, estimateMessageTokens, estimatePromptTokens, Compaction_exports as t };
+
+//# sourceMappingURL=Compaction.mjs.map

package/dist/engine/Compaction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compaction.mjs","names":[],"sources":["../../src/engine/Compaction.ts"],"sourcesContent":["/** Public Compaction API. Implementation helpers remain private. */\nexport {\n  CLEARED_TOOL_RESULT,\n  COMPACTION_SUMMARY_PREFIX,\n  CONTEXT_ROLLOVER_PREFIX,\n  contextWindowId,\n  contextWindowMessage,\n  estimateMessageTokens,\n  estimatePromptTokens,\n  type ContextCompactionState,\n} from \"./internal/compaction.ts\";\n"],"mappings":""}

package/dist/engine/ContextCompactor.d.mts

@@ -0,0 +1,2 @@
+import { a as ContextCompaction, c as ContextMessageTokenEstimator, i as CompactionRequest, n as CompactionError, o as ContextCompactor, r as CompactionModelLayer, t as CompactionDecision } from "../ContextCompactor-WwSIG_Z2.mjs";
+export { CompactionDecision, CompactionError, CompactionModelLayer, CompactionRequest, ContextCompaction, ContextCompactor, ContextMessageTokenEstimator };

package/dist/engine/ContextCompactor.mjs

@@ -0,0 +1,119 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { a as SUMMARY_REQUEST_PREFIX, c as buildRolloverHandoff, d as collectCoveredMessages, g as evaluateMessageTokenEstimates, h as estimatePromptTokens, i as SUMMARY_MAX_LENGTH, l as choosePruneBound, o as SUMMARY_REQUEST_SUFFIX, s as buildCompactedView, u as chooseSummarizeCut, y as renderForSummary } from "../compaction-C2OTceKw.mjs";
+import { ContextHandoff } from "./ContextWindow.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
+//#region src/engine/ContextCompactor.ts
+var ContextCompactor_exports = /* @__PURE__ */ __exportAll({
+	CompactionDecision: () => CompactionDecision,
+	CompactionError: () => CompactionError,
+	ContextCompactor: () => ContextCompactor
+});
+/**
+* A proposed view change. Source indices are exclusive prefix bounds, never record sequences.
+* Summaries contain at most 65,536 characters; the interpreter rejects oversized decisions
+* before committing or changing coverage.
+*/
+const CompactionDecision = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("rollover"),
+		through: Schema.Natural,
+		handoff: Schema.optionalKey(ContextHandoff)
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("clear-tool-results"),
+		through: Schema.Natural
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("summarize"),
+		through: Schema.Natural,
+		summary: Schema.NonEmptyString.check(Schema.isMaxLength(SUMMARY_MAX_LENGTH), Schema.isPattern(/\S/))
+	})
+]);
+/** Expected strategy or decision-validation failure. Causes stay in the live Effect only. */
+var CompactionError = class extends Schema.TaggedError()("CompactionError", {
+	message: Schema.String.check(Schema.isMaxLength(4096)),
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const evaluateEstimates = (override, operation) => Effect.suspend(() => {
+	const result = evaluateMessageTokenEstimates(override, operation);
+	return Option.isSome(result) ? Effect.succeed(result.value) : CompactionError.make({ message: "Message token estimator returned an invalid token count" });
+});
+const defaultCompactor = (model) => ({
+	estimate: estimatePromptTokens,
+	compact: (request) => Stream.unwrap(Effect.gen(function* () {
+		const { source, policy, targetTokens, trigger, modelCallAllowed } = request;
+		if (request.requested !== void 0) return Stream.succeed({
+			kind: "rollover",
+			...request.requested
+		});
+		const forceSummarize = trigger === "overflow";
+		const state = { ...request.state };
+		const keepRecentTokens = targetTokens === void 0 ? policy.keepRecentTokens : Math.max(1, Math.min(policy.keepRecentTokens, targetTokens));
+		const decisions = [];
+		if (!forceSummarize && policy.mode !== "summarize") {
+			const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => choosePruneBound(source.content, state, keepRecentTokens, targetTokens, estimate));
+			if (through > state.clearedThrough) {
+				state.clearedThrough = through;
+				decisions.push({
+					kind: "clear-tool-results",
+					through
+				});
+				if (targetTokens !== void 0 && (yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => estimatePromptTokens(buildCompactedView(source.content, state), estimate))) <= targetTokens) return Stream.fromIterable(decisions);
+			}
+		}
+		const prune = Stream.fromIterable(decisions);
+		if ((!modelCallAllowed || policy.mode === "prune") && !forceSummarize) return prune;
+		return prune.pipe(Stream.concat(Stream.unwrap(Effect.gen(function* () {
+			const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => chooseSummarizeCut(source.content, state, keepRecentTokens, estimate));
+			const covered = collectCoveredMessages(source.content, state, through);
+			if (covered.length === 0) return Stream.empty;
+			const transcript = renderForSummary(covered, state.replacement?.kind === "summarize" ? state.replacement.summary : state.replacement?.handoff);
+			if (transcript === void 0) return yield* CompactionError.make({ message: `Previous compaction summary exceeds ${SUMMARY_MAX_LENGTH} characters` });
+			const prompt = Prompt.fromMessages([Prompt.userMessage({ content: [Prompt.textPart({ text: `${SUMMARY_REQUEST_PREFIX}${transcript}${SUMMARY_REQUEST_SUFFIX}` })] })]);
+			const text = yield* request.summarize(prompt, model);
+			return Stream.succeed({
+				kind: "summarize",
+				through,
+				summary: text.trim()
+			});
+		}))));
+	}))
+});
+/**
+* The sole interpreter compaction port. Runs without an installed service provide layer at their
+* composition boundary. Decorators yield this service during construction and receive their
+* underlying implementation through Layer.provide. Direct harnesses use the same Layer contract.
+*/
+var ContextCompactor = class ContextCompactor extends Context.Service()("@effect-agent/engine/ContextCompactor") {
+	static layer = Layer.succeed(ContextCompactor, defaultCompactor());
+	/**
+	* Start fresh windows without a summarizer call. The engine retains instructions/input and
+	* commits each boundary; a bounded emergency handoff preserves user inputs and unseen results.
+	* Applications provide notes/history tools alongside this strategy.
+	*/
+	static layerRollover = Layer.succeed(ContextCompactor, {
+		estimate: estimatePromptTokens,
+		compact: (request) => Stream.unwrap(Effect.gen(function* () {
+			if (request.requested !== void 0) return Stream.succeed({
+				kind: "rollover",
+				...request.requested
+			});
+			const through = request.source.content.findLastIndex((message) => message.role === "assistant" || message.role === "tool") + 1;
+			if (collectCoveredMessages(request.source.content, request.state, through).length === 0) return Stream.empty;
+			const handoff = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => buildRolloverHandoff(request.source.content, request.state, request.targetTokens, through, estimate));
+			if (handoff === void 0) return Stream.fail(CompactionError.make({ message: "Insufficient context capacity for an automatic rollover handoff" }));
+			return Stream.succeed({
+				kind: "rollover",
+				through,
+				handoff
+			});
+		}))
+	});
+	/** Use the bounded default algorithm with a separate upstream Effect AI Model. */
+	static layerWithModel = (model) => Layer.effect(ContextCompactor, Effect.map(model.captureRequirements, (captured) => defaultCompactor(captured)));
+};
+//#endregion
+export { CompactionDecision, CompactionError, ContextCompactor, ContextCompactor_exports as t };
+
+//# sourceMappingURL=ContextCompactor.mjs.map