effect-agent 0.1.0-beta.15 → 0.1.0-beta.151

package/dist/durable/WorkerHost.d.mts

@@ -0,0 +1,156 @@
+import { l as SubmissionId, t as AgentId, 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-Cjd_ZveM.mjs";
+import { c as WorkerError, f as WorkerRef, h as WorkerSource } from "../Worker-fwWkBg12.mjs";
+import { O as PersistedJson, _ as Digest, d as CanonicalSequence, ft as WorkerOrigin, h as DefinitionDigests, lt as WorkerContinuation } from "../Records-B5GFWCpn.mjs";
+import { Tn as SubmissionSnapshot } from "../Admin-CKIdJoP8.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+declare namespace WorkerHost_d_exports {
+  export { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizationRequest, WorkerHostAuthorizer, WorkerHostConfig, WorkerHostLimits, WorkerPolicyResolver, WorkerPolicySource, WorkerPolicyTarget, WorkerStartAdmission };
+}
+/**
+ * One successful start authorization at an exact source tail. This host-created hint is
+ * available only during that start's preparation and synchronous admission; it is never
+ * persisted or transported. Hooks may reuse their admission decision, but must retain
+ * current access checks at commit boundaries. A retry or changed tail gets no old grant.
+ */
+export interface WorkerStartAdmission {
+  readonly sourceThreadId: ThreadId;
+  readonly sourceSubmissionId?: SubmissionId;
+  readonly requestedPrincipal: Principal;
+  readonly principal: Principal;
+  readonly targetAgentId: AgentId;
+  readonly continuationOf?: WorkerContinuation;
+  readonly access: "send";
+  readonly tailSequence: CanonicalSequence;
+  readonly tailDigest: Digest;
+}
+/** 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 admission?: WorkerStartAdmission;
+  readonly continuationOf?: WorkerContinuation;
+  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 continuationOf?: WorkerContinuation;
+    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 admission?: WorkerStartAdmission;
+  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"];
+  /** Report access follows native frozen-message proof and preserves the destination principal. */
+  readonly access: "context" | "read" | "send" | "control" | "report";
+  readonly worker?: WorkerRef;
+  /** Native-verified successful predecessor, never a caller-supplied authorization grant. */
+  readonly continuationOf?: WorkerContinuation;
+}
+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 admission?: WorkerStartAdmission;
+    readonly principal: Principal;
+    readonly worker: WorkerRef;
+    readonly continuationOf?: WorkerContinuation;
+    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 { AgentId, 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 {\n  CanonicalSequence,\n  DefinitionDigests,\n  Digest,\n  PersistedJson,\n  WorkerOrigin,\n  WorkerContinuation,\n} from \"./Records.ts\";\nimport type { Principal, SubmissionSnapshot } from \"./SubmissionLedger.ts\";\n\n/**\n * One successful start authorization at an exact source tail. This host-created hint is\n * available only during that start's preparation and synchronous admission; it is never\n * persisted or transported. Hooks may reuse their admission decision, but must retain\n * current access checks at commit boundaries. A retry or changed tail gets no old grant.\n */\nexport interface WorkerStartAdmission {\n  readonly sourceThreadId: ThreadId;\n  readonly sourceSubmissionId?: SubmissionId;\n  readonly requestedPrincipal: Principal;\n  readonly principal: Principal;\n  readonly targetAgentId: AgentId;\n  readonly continuationOf?: WorkerContinuation;\n  readonly access: \"send\";\n  readonly tailSequence: CanonicalSequence;\n  readonly tailDigest: Digest;\n}\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 admission?: WorkerStartAdmission;\n      readonly continuationOf?: WorkerContinuation;\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 continuationOf?: WorkerContinuation;\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 admission?: WorkerStartAdmission;\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  /** Report access follows native frozen-message proof and preserves the destination principal. */\n  readonly access: \"context\" | \"read\" | \"send\" | \"control\" | \"report\";\n  readonly worker?: WorkerRef;\n  /** Native-verified successful predecessor, never a caller-supplied authorization grant. */\n  readonly continuationOf?: WorkerContinuation;\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 admission?: WorkerStartAdmission;\n    readonly principal: Principal;\n    readonly worker: WorkerRef;\n    readonly continuationOf?: WorkerContinuation;\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":";;;;;;;;;;;;;;;;;;;;;;AAyEA,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,UAQ9C,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;AAsBA,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,UAU3C,+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-sXpKcyxu.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-D8U9gl9Q.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

package/dist/engine/ContextCompactor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextCompactor.mjs","names":[],"sources":["../../src/engine/ContextCompactor.ts"],"sourcesContent":["import { Context, Effect, Layer, Option, Schema, Stream } from \"effect\";\nimport { type LanguageModel, type Model, Prompt } from \"effect/unstable/ai\";\n\nimport { type CompactionPolicy } from \"../core/AgentPolicy.ts\";\nimport { type RunId, type ThreadId } from \"../core/Identifiers.ts\";\nimport { ContextHandoff, type ContextRolloverRequest } from \"./ContextWindow.ts\";\nimport {\n  buildCompactedView,\n  buildRolloverHandoff,\n  choosePruneBound,\n  chooseSummarizeCut,\n  collectCoveredMessages,\n  estimatePromptTokens,\n  evaluateMessageTokenEstimates,\n  renderForSummary,\n  SUMMARY_MAX_LENGTH,\n  SUMMARY_REQUEST_PREFIX,\n  SUMMARY_REQUEST_SUFFIX,\n  type ContextCompactionState,\n} from \"./internal/compaction.ts\";\n\n/**\n * A proposed view change. Source indices are exclusive prefix bounds, never record sequences.\n * Summaries contain at most 65,536 characters; the interpreter rejects oversized decisions\n * before committing or changing coverage.\n */\nexport const CompactionDecision = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"rollover\"),\n    through: Schema.Natural,\n    handoff: Schema.optionalKey(ContextHandoff),\n  }),\n  Schema.Struct({ kind: Schema.Literal(\"clear-tool-results\"), through: Schema.Natural }),\n  Schema.Struct({\n    kind: Schema.Literal(\"summarize\"),\n    through: Schema.Natural,\n    summary: Schema.NonEmptyString.check(\n      Schema.isMaxLength(SUMMARY_MAX_LENGTH),\n      Schema.isPattern(/\\S/),\n    ),\n  }),\n]);\n\nexport type CompactionDecision = typeof CompactionDecision.Type;\n\n/** Expected strategy or decision-validation failure. Causes stay in the live Effect only. */\nexport class CompactionError extends Schema.TaggedError<CompactionError>()(\"CompactionError\", {\n  message: Schema.String.check(Schema.isMaxLength(4_096)),\n  cause: Schema.optionalKey(Schema.Defect()),\n}) {}\n\n/** Upstream Model.captureRequirements returns this closed Layer. */\nexport type CompactionModelLayer = Layer.Layer<\n  LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName\n>;\n\n/** A full message estimate, or undefined to use the native structural estimate. */\nexport type ContextMessageTokenEstimator = (message: Prompt.Message) => number | undefined;\n\n/**\n * One bounded pass over an immutable source snapshot. A harness owns state, metering, and\n * application of decisions. The interpreter permits at most one prune followed by one replacement\n * (summary or rollover), and one call to summarize per Turn, shared across every trigger.\n * All model work must use summarize so it is metered.\n * Callback failures and requirements pass through unchanged; strategy dependencies belong to\n * its construction Layer. Protected messages cannot be removed and Tool pairs cannot be split by a decision.\n */\nexport interface CompactionRequest<E, R> {\n  readonly threadId: ThreadId;\n  readonly runId: RunId;\n  readonly turn: number;\n  readonly source: Prompt.Prompt;\n  readonly state: Readonly<ContextCompactionState>;\n  readonly policy: CompactionPolicy;\n  readonly targetTokens: number | undefined;\n  readonly trigger: \"pressure\" | \"overflow\" | \"requested\";\n  /** Budget admission may prohibit a separate model call while still allowing a rollover. */\n  readonly modelCallAllowed: boolean;\n  /** The current captured Model's message accounting, including native fallback. */\n  readonly estimateMessageTokens?: ContextMessageTokenEstimator | undefined;\n  /** Present for a successful, singleton context rollover Tool; through excludes later steering. */\n  readonly requested?: (ContextRolloverRequest & { readonly through: number }) | undefined;\n  readonly summarize: (\n    prompt: Prompt.Prompt,\n    model?: CompactionModelLayer,\n  ) => Effect.Effect<string, E, R>;\n}\n\nexport interface ContextCompaction {\n  /** Non-negative finite integer estimate, used for admission and derived prompt overhead too. */\n  readonly estimate: (messages: ReadonlyArray<Prompt.Message>) => number;\n  /** Emit decisions sequentially; the consumer commits each before pulling the next. */\n  readonly compact: <E, R>(\n    request: CompactionRequest<E, R>,\n  ) => Stream.Stream<CompactionDecision, E | CompactionError, R>;\n}\n\nconst evaluateEstimates = <A>(\n  override: ContextMessageTokenEstimator | undefined,\n  operation: (estimate: (message: Prompt.Message) => number) => A,\n): Effect.Effect<A, CompactionError> =>\n  Effect.suspend(() => {\n    const result = evaluateMessageTokenEstimates(override, operation);\n\n    return Option.isSome(result)\n      ? Effect.succeed(result.value)\n      : CompactionError.make({\n          message: \"Message token estimator returned an invalid token count\",\n        });\n  });\n\nconst defaultCompactor = (model?: CompactionModelLayer): ContextCompaction => ({\n  estimate: estimatePromptTokens,\n  compact: <E, R>(request: CompactionRequest<E, R>) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const { source, policy, targetTokens, trigger, modelCallAllowed } = request;\n\n        if (request.requested !== undefined) {\n          return Stream.succeed({ kind: \"rollover\", ...request.requested });\n        }\n        const forceSummarize = trigger === \"overflow\";\n        const state = { ...request.state };\n\n        const keepRecentTokens =\n          targetTokens === undefined\n            ? policy.keepRecentTokens\n            : Math.max(1, Math.min(policy.keepRecentTokens, targetTokens));\n\n        const decisions: Array<CompactionDecision> = [];\n\n        if (!forceSummarize && policy.mode !== \"summarize\") {\n          const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n            choosePruneBound(source.content, state, keepRecentTokens, targetTokens, estimate),\n          );\n\n          if (through > state.clearedThrough) {\n            state.clearedThrough = through;\n            decisions.push({ kind: \"clear-tool-results\", through });\n            if (\n              targetTokens !== undefined &&\n              (yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n                estimatePromptTokens(buildCompactedView(source.content, state), estimate),\n              )) <= targetTokens\n            ) {\n              return Stream.fromIterable(decisions);\n            }\n          }\n        }\n        const prune = Stream.fromIterable(decisions);\n\n        if ((!modelCallAllowed || policy.mode === \"prune\") && !forceSummarize) return prune;\n\n        return prune.pipe(\n          Stream.concat(\n            Stream.unwrap(\n              Effect.gen(function* () {\n                const through = yield* evaluateEstimates(\n                  request.estimateMessageTokens,\n                  (estimate) =>\n                    chooseSummarizeCut(source.content, state, keepRecentTokens, estimate),\n                );\n\n                const covered = collectCoveredMessages(source.content, state, through);\n\n                if (covered.length === 0) return Stream.empty;\n\n                const transcript = renderForSummary(\n                  covered,\n                  state.replacement?.kind === \"summarize\"\n                    ? state.replacement.summary\n                    : state.replacement?.handoff,\n                );\n\n                if (transcript === undefined) {\n                  return yield* CompactionError.make({\n                    message: `Previous compaction summary exceeds ${SUMMARY_MAX_LENGTH} characters`,\n                  });\n                }\n\n                const prompt = Prompt.fromMessages([\n                  Prompt.userMessage({\n                    content: [\n                      Prompt.textPart({\n                        text: `${SUMMARY_REQUEST_PREFIX}${transcript}${SUMMARY_REQUEST_SUFFIX}`,\n                      }),\n                    ],\n                  }),\n                ]);\n\n                const text = yield* request.summarize(prompt, model);\n\n                return Stream.succeed({\n                  kind: \"summarize\",\n                  through,\n                  summary: text.trim(),\n                } satisfies CompactionDecision);\n              }),\n            ),\n          ),\n        );\n      }),\n    ),\n});\n\n/**\n * The sole interpreter compaction port. Runs without an installed service provide layer at their\n * composition boundary. Decorators yield this service during construction and receive their\n * underlying implementation through Layer.provide. Direct harnesses use the same Layer contract.\n */\nexport class ContextCompactor extends Context.Service<ContextCompactor, ContextCompaction>()(\n  \"@effect-agent/engine/ContextCompactor\",\n) {\n  static readonly layer = Layer.succeed(ContextCompactor, defaultCompactor());\n\n  /**\n   * Start fresh windows without a summarizer call. The engine retains instructions/input and\n   * commits each boundary; a bounded emergency handoff preserves user inputs and unseen results.\n   * Applications provide notes/history tools alongside this strategy.\n   */\n  static readonly layerRollover = Layer.succeed(ContextCompactor, {\n    estimate: estimatePromptTokens,\n    compact: <E, R>(request: CompactionRequest<E, R>) =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          if (request.requested !== undefined) {\n            return Stream.succeed({\n              kind: \"rollover\",\n              ...request.requested,\n            } satisfies CompactionDecision);\n          }\n\n          // Trailing user steering may not be canonical until the next response. Keep it verbatim.\n          const through =\n            request.source.content.findLastIndex(\n              (message) => message.role === \"assistant\" || message.role === \"tool\",\n            ) + 1;\n\n          if (collectCoveredMessages(request.source.content, request.state, through).length === 0) {\n            return Stream.empty;\n          }\n\n          const handoff = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n            buildRolloverHandoff(\n              request.source.content,\n              request.state,\n              request.targetTokens,\n              through,\n              estimate,\n            ),\n          );\n\n          if (handoff === undefined)\n            return Stream.fail(\n              CompactionError.make({\n                message: \"Insufficient context capacity for an automatic rollover handoff\",\n              }),\n            );\n\n          return Stream.succeed({\n            kind: \"rollover\",\n            through,\n            handoff,\n          } satisfies CompactionDecision);\n        }),\n      ),\n  });\n\n  /** Use the bounded default algorithm with a separate upstream Effect AI Model. */\n  static readonly layerWithModel = <Provider, Requirements>(\n    model: Model.Model<Provider, LanguageModel.LanguageModel, Requirements>,\n  ): Layer.Layer<ContextCompactor, never, Requirements> =>\n    Layer.effect(\n      ContextCompactor,\n      Effect.map(model.captureRequirements, (captured) => defaultCompactor(captured)),\n    );\n}\n"],"mappings":"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"}

package/dist/engine/ContextHistory.d.mts

@@ -0,0 +1,65 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace ContextHistory_d_exports {
+  export { ContextHistory, ContextHistoryError, ContextHistoryHit, ContextHistoryPage, ContextHistoryRead, ContextHistorySearch };
+}
+declare const ContextHistoryError_base: Schema.Class<ContextHistoryError, Schema.TaggedStruct<"ContextHistoryError", {
+  readonly reason: Schema.Literals<readonly ["unavailable", "not-found", "invalid-input", "limit"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */
+export declare class ContextHistoryError extends ContextHistoryError_base {}
+declare const ContextHistoryHit_base: Schema.Class<ContextHistoryHit, Schema.Struct<{
+  readonly recordId: Schema.NonEmptyString;
+  readonly windowId: Schema.NonEmptyString;
+  readonly text: Schema.String;
+}>, {}>;
+export declare class ContextHistoryHit extends ContextHistoryHit_base {}
+declare const ContextHistorySearch_base: Schema.Class<ContextHistorySearch, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly query: Schema.NonEmptyString;
+  readonly limit: Schema.Int;
+  readonly beforeRecordId: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).
+ * `beforeRecordId` excludes that record and every newer canonical position. Use the last hit
+ * from the previous page with the same query; fewer than `limit` hits (including zero) ends
+ * pagination. A full final page requires one more request to observe the empty page.
+ *
+ * The anchor must be eligible retained evidence in this authorized Thread, but need not match
+ * the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.
+ * IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.
+ * Each request captures its own tail; this is not a snapshot held across requests. New appends
+ * cannot displace matches older than the anchor. Retention and authorization are rechecked.
+ */
+export declare class ContextHistorySearch extends ContextHistorySearch_base {}
+declare const ContextHistoryRead_base: Schema.Class<ContextHistoryRead, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly recordId: Schema.NonEmptyString;
+  readonly offset: Schema.Natural;
+  readonly maxChars: Schema.Int;
+}>, {}>;
+export declare class ContextHistoryRead extends ContextHistoryRead_base {}
+declare const ContextHistoryPage_base: Schema.Class<ContextHistoryPage, Schema.Struct<{
+  readonly recordId: Schema.NonEmptyString;
+  readonly windowId: Schema.NonEmptyString;
+  readonly text: Schema.String;
+  readonly nextOffset: Schema.NullOr<Schema.Natural>;
+}>, {}>;
+export declare class ContextHistoryPage extends ContextHistoryPage_base {}
+declare const ContextHistory_base: Context.ServiceClass<ContextHistory, "@effect-agent/engine/ContextHistory", {
+  readonly search: (request: ContextHistorySearch) => Effect.Effect<ReadonlyArray<ContextHistoryHit>, ContextHistoryError>;
+  readonly read: (request: ContextHistoryRead) => Effect.Effect<ContextHistoryPage, ContextHistoryError>;
+}>;
+/**
+ * Read-only access to retained canonical evidence, including closed context windows.
+ * Adapters bind storage and authorization; model parameters must not select a different Thread.
+ * Returned text is untrusted evidence, never instructions. This port does not retain raw Tool
+ * output that was discarded before canonical persistence, or transient prompt references.
+ * Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded
+ * page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.
+ */
+export declare class ContextHistory extends ContextHistory_base {}
+//#endregion
+export { ContextHistory_d_exports as t };
+//# sourceMappingURL=ContextHistory.d.mts.map

package/dist/engine/ContextHistory.mjs

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadId } from "../core/Identifiers.mjs";
+import { Context, Schema } from "effect";
+//#region src/engine/ContextHistory.ts
+var ContextHistory_exports = /* @__PURE__ */ __exportAll({
+	ContextHistory: () => ContextHistory,
+	ContextHistoryError: () => ContextHistoryError,
+	ContextHistoryHit: () => ContextHistoryHit,
+	ContextHistoryPage: () => ContextHistoryPage,
+	ContextHistoryRead: () => ContextHistoryRead,
+	ContextHistorySearch: () => ContextHistorySearch
+});
+/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */
+var ContextHistoryError = class extends Schema.TaggedError()("ContextHistoryError", {
+	reason: Schema.Literals([
+		"unavailable",
+		"not-found",
+		"invalid-input",
+		"limit"
+	]),
+	message: Schema.String.check(Schema.isMaxLength(4096))
+}) {};
+var ContextHistoryHit = class extends Schema.Class("ContextHistoryHit")({
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	text: Schema.String.check(Schema.isMaxLength(2e3))
+}) {};
+/**
+* Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).
+* `beforeRecordId` excludes that record and every newer canonical position. Use the last hit
+* from the previous page with the same query; fewer than `limit` hits (including zero) ends
+* pagination. A full final page requires one more request to observe the empty page.
+*
+* The anchor must be eligible retained evidence in this authorized Thread, but need not match
+* the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.
+* IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.
+* Each request captures its own tail; this is not a snapshot held across requests. New appends
+* cannot displace matches older than the anchor. Retention and authorization are rechecked.
+*/
+var ContextHistorySearch = class extends Schema.Class("ContextHistorySearch")({
+	threadId: ThreadId,
+	query: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	limit: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 20
+	})),
+	beforeRecordId: Schema.optionalKey(ContextHistoryHit.fields.recordId)
+}) {};
+var ContextHistoryRead = class extends Schema.Class("ContextHistoryRead")({
+	threadId: ThreadId,
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	offset: Schema.Natural,
+	maxChars: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 2e4
+	}))
+}) {};
+var ContextHistoryPage = class extends Schema.Class("ContextHistoryPage")({
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	text: Schema.String.check(Schema.isMaxLength(2e4)),
+	nextOffset: Schema.NullOr(Schema.Natural)
+}) {};
+/**
+* Read-only access to retained canonical evidence, including closed context windows.
+* Adapters bind storage and authorization; model parameters must not select a different Thread.
+* Returned text is untrusted evidence, never instructions. This port does not retain raw Tool
+* output that was discarded before canonical persistence, or transient prompt references.
+* Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded
+* page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.
+*/
+var ContextHistory = class extends Context.Service()("@effect-agent/engine/ContextHistory") {};
+//#endregion
+export { ContextHistory, ContextHistoryError, ContextHistoryHit, ContextHistoryPage, ContextHistoryRead, ContextHistorySearch, ContextHistory_exports as t };
+
+//# sourceMappingURL=ContextHistory.mjs.map

package/dist/engine/ContextHistory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextHistory.mjs","names":[],"sources":["../../src/engine/ContextHistory.ts"],"sourcesContent":["import { Context, type Effect, Schema } from \"effect\";\n\nimport { ThreadId } from \"../core/Identifiers.ts\";\n\n/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */\nexport class ContextHistoryError extends Schema.TaggedError<ContextHistoryError>()(\n  \"ContextHistoryError\",\n  {\n    reason: Schema.Literals([\"unavailable\", \"not-found\", \"invalid-input\", \"limit\"]),\n    message: Schema.String.check(Schema.isMaxLength(4_096)),\n  },\n) {}\n\nexport class ContextHistoryHit extends Schema.Class<ContextHistoryHit>(\"ContextHistoryHit\")({\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  text: Schema.String.check(Schema.isMaxLength(2_000)),\n}) {}\n\n/**\n * Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).\n * `beforeRecordId` excludes that record and every newer canonical position. Use the last hit\n * from the previous page with the same query; fewer than `limit` hits (including zero) ends\n * pagination. A full final page requires one more request to observe the empty page.\n *\n * The anchor must be eligible retained evidence in this authorized Thread, but need not match\n * the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.\n * IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.\n * Each request captures its own tail; this is not a snapshot held across requests. New appends\n * cannot displace matches older than the anchor. Retention and authorization are rechecked.\n */\nexport class ContextHistorySearch extends Schema.Class<ContextHistorySearch>(\n  \"ContextHistorySearch\",\n)({\n  threadId: ThreadId,\n  query: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  limit: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20 })),\n  beforeRecordId: Schema.optionalKey(ContextHistoryHit.fields.recordId),\n}) {}\n\nexport class ContextHistoryRead extends Schema.Class<ContextHistoryRead>(\"ContextHistoryRead\")({\n  threadId: ThreadId,\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  offset: Schema.Natural,\n  maxChars: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20_000 })),\n}) {}\n\nexport class ContextHistoryPage extends Schema.Class<ContextHistoryPage>(\"ContextHistoryPage\")({\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  text: Schema.String.check(Schema.isMaxLength(20_000)),\n  nextOffset: Schema.NullOr(Schema.Natural),\n}) {}\n\n/**\n * Read-only access to retained canonical evidence, including closed context windows.\n * Adapters bind storage and authorization; model parameters must not select a different Thread.\n * Returned text is untrusted evidence, never instructions. This port does not retain raw Tool\n * output that was discarded before canonical persistence, or transient prompt references.\n * Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded\n * page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.\n */\nexport class ContextHistory extends Context.Service<\n  ContextHistory,\n  {\n    readonly search: (\n      request: ContextHistorySearch,\n    ) => Effect.Effect<ReadonlyArray<ContextHistoryHit>, ContextHistoryError>;\n    readonly read: (\n      request: ContextHistoryRead,\n    ) => Effect.Effect<ContextHistoryPage, ContextHistoryError>;\n  }\n>()(\"@effect-agent/engine/ContextHistory\") {}\n"],"mappings":";;;;;;;;;;;;;AAKA,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,QAAQ,OAAO,SAAS;EAAC;EAAe;EAAa;EAAiB;CAAO,CAAC;CAC9E,SAAS,OAAO,OAAO,MAAM,OAAO,YAAY,IAAK,CAAC;AACxD,CACF,CAAC,CAAC,CAAC;AAEH,IAAa,oBAAb,cAAuC,OAAO,MAAyB,mBAAmB,CAAC,CAAC;CAC1F,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,MAAM,OAAO,OAAO,MAAM,OAAO,YAAY,GAAK,CAAC;AACrD,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;AAcJ,IAAa,uBAAb,cAA0C,OAAO,MAC/C,sBACF,CAAC,CAAC;CACA,UAAU;CACV,OAAO,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC1D,OAAO,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAG,CAAC,CAAC;CACrE,gBAAgB,OAAO,YAAY,kBAAkB,OAAO,QAAQ;AACtE,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,qBAAb,cAAwC,OAAO,MAA0B,oBAAoB,CAAC,CAAC;CAC7F,UAAU;CACV,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,QAAQ,OAAO;CACf,UAAU,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAO,CAAC,CAAC;AAC9E,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,qBAAb,cAAwC,OAAO,MAA0B,oBAAoB,CAAC,CAAC;CAC7F,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,MAAM,OAAO,OAAO,MAAM,OAAO,YAAY,GAAM,CAAC;CACpD,YAAY,OAAO,OAAO,OAAO,OAAO;AAC1C,CAAC,CAAC,CAAC,CAAC;;;;;;;;;AAUJ,IAAa,iBAAb,cAAoC,QAAQ,QAU1C,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC"}

package/dist/engine/ContextWindow.d.mts

@@ -0,0 +1,2 @@
+import { a as ContextWindow, c as ModelCallContext, i as ContextRolloverTool, n as ContextRolloverRequest, o as ContextWindowStatus, r as ContextRolloverSelection, t as ContextHandoff } from "../ContextWindow-DRQ5Mbm2.mjs";
+export { ContextHandoff, ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext };