@@ -1903,6 +1903,65 @@ describe('[#20515] with no active organization, only global grants apply', () =>
     });
   });
 
+  /**
+   * §6a — position-bound sets. Under a walled posture the catalog holds one
+   * copy of each built-in position PER ORGANIZATION (`everyone`, `org_member`,
+   * …), and an organization binds its own sets to its own copies. With no
+   * tenant the `sys_position` read is installation-wide, so every
+   * organization's copy of a name the caller holds used to feed its bindings in.
+   * This double ignores the context's tenant exactly as that read does.
+   */
+  describe('§6a: a position row scoped to an organization binds nothing with no tenant', () => {
+    const catalog = () => ({
+      sys_position: [
+        { id: 'pos_member_alpha', name: 'org_member', organization_id: ALPHA },
+        { id: 'pos_member_beta', name: 'org_member', organization_id: BETA },
+        { id: 'pos_everyone_alpha', name: 'everyone', organization_id: ALPHA },
+        { id: 'pos_everyone_global', name: 'everyone', organization_id: null },
+      ],
+      sys_position_permission_set: [
+        { position_id: 'pos_member_alpha', permission_set_id: 'ps_alpha_members' },
+        { position_id: 'pos_everyone_alpha', permission_set_id: 'ps_alpha_everyone' },
+        { position_id: 'pos_everyone_global', permission_set_id: 'ps_global_everyone' },
+      ],
+      sys_permission_set: [
+        { id: 'ps_alpha_members', name: 'alpha_member_tools', system_permissions: ['manage_metadata'] },
+        { id: 'ps_alpha_everyone', name: 'alpha_everyone_extra' },
+        { id: 'ps_global_everyone', name: 'global_everyone_default' },
+      ],
+    });
+    /** Removed from alpha, still an `org_member` of beta — the role name alpha bound its set to. */
+    const exMember = () => makeQl({
+      sys_user: [{ id: 'u_ex' }],
+      sys_member: [{ user_id: 'u_ex', organization_id: BETA, role: 'member' }],
+      sys_user_position: [],
+      sys_user_permission_set: [],
+      ...catalog(),
+    });
+
+    it('no tenant: neither alpha\'s org_member binding nor alpha\'s everyone binding applies; the global everyone binding does', async () => {
+      const grants = await resolveUserAuthzGrants(exMember(), 'u_ex', {});
+      expect(grants.positions).toContain('org_member');
+      expect([...grants.permissions].sort()).toEqual(['global_everyone_default']);
+      expect(grants.systemPermissions).not.toContain('manage_metadata');
+    });
+
+    it('in beta: alpha\'s bindings still do not apply; in alpha (a current member there): they do', async () => {
+      const inBeta = await resolveUserAuthzGrants(exMember(), 'u_ex', { tenantId: BETA });
+      expect([...inBeta.permissions].sort()).toEqual(['global_everyone_default']);
+      const alphaMember = makeQl({
+        sys_user: [{ id: 'u_in' }],
+        sys_member: [{ user_id: 'u_in', organization_id: ALPHA, role: 'member' }],
+        sys_user_position: [],
+        sys_user_permission_set: [],
+        ...catalog(),
+      });
+      const inAlpha = await resolveUserAuthzGrants(alphaMember, 'u_in', { tenantId: ALPHA });
+      expect([...inAlpha.permissions].sort()).toEqual(['alpha_everyone_extra', 'alpha_member_tools', 'global_everyone_default']);
+      expect(inAlpha.systemPermissions).toContain('manage_metadata');
+    });
+  });
+
   describe('through the session arm: the removed member whose claim is dropped', () => {
     /**
      * `u_ex` was removed from `org_alpha` and is still a member of `org_beta`;
 
@@ -622,12 +622,12 @@ export interface ResolveUserAuthzGrantsOptions {
 }
 
 /**
- * The ONE organization rule for a stored grant row — `sys_user_position` (§4)
- * and `sys_user_permission_set` (§6) both ask it, so the two cannot disagree:
- * a row with no `organization_id` is GLOBAL and applies in every resolution; a
- * row scoped to an organization applies only when that organization is the
- * ACTIVE tenant. With no active tenant, an organization-scoped row does not
- * apply at all.
+ * The ONE organization rule for a stored grant row — `sys_user_position` (§4),
+ * `sys_user_permission_set` (§6) and the `sys_position` rows whose bindings
+ * §6a collects all ask it, so none of them can disagree: a row with no
+ * `organization_id` is GLOBAL and applies in every resolution; a row scoped to
+ * an organization applies only when that organization is the ACTIVE tenant.
+ * With no active tenant, an organization-scoped row does not apply at all.
  *
  * The spelling both sites carried before, `org && tenantId && org !== tenantId`
  * as the SKIP condition, read "no tenant" as "every organization": it was false
@@ -643,9 +643,10 @@ export interface ResolveUserAuthzGrantsOptions {
  * that has none gets the global grants and nothing else.
  *
  * ⚠️ Not applied to §3's `sys_member` role projection, which reads the user's
- * OWN memberships rather than a grant row, nor to §6a's `sys_position` read,
- * which is scoped by threading the organization into the driver's tenant scope
- * rather than by filtering rows here.
+ * OWN current memberships rather than a grant row. With no active organization
+ * that projection still names every membership's role; what a role name can
+ * CONFER arrives through §6a's per-organization position rows and §6's
+ * organization-scoped grants, and both answer to this rule.
  */
 function grantAppliesInTenant(organizationId: unknown, tenantId: string | undefined): boolean {
   return !organizationId || organizationId === tenantId;
@@ -948,7 +949,22 @@ export async function resolveUserAuthzGrants(
     //     organization-less rows stay REACHABLE on purpose — they are not
     //     reaped, and grants point at them by row id, so dropping them here
     //     would revoke standing access silently.
-    const positionRows = await tryFind(ql, 'sys_position', { name: { $in: grants.positions } }, 200, tenantId);
+    //
+    //     [#20515] The same grant rule as §4 and §6 is then asked of each
+    //     position row ({@link grantAppliesInTenant}). With a tenant it is a
+    //     no-op — the driver's scope already returned only this organization's
+    //     rows and the organization-less ones. With NO tenant the read above is
+    //     installation-wide by design, so without it every organization's
+    //     `everyone` row, and every organization's copy of a name the caller
+    //     holds (the `sys_member` role projection's `org_member`, say), fed its
+    //     bindings into an organization-less resolution: measured on a real
+    //     `SqlDriver` over the shipped per-organization catalog, a member
+    //     removed from an organization kept the `manage_metadata` set that
+    //     organization had bound to its `org_member` position. This is the
+    //     grant rule, not a second tenant wall: it decides which organization's
+    //     bindings APPLY, after the driver decided which rows are visible.
+    const positionRows = (await tryFind(ql, 'sys_position', { name: { $in: grants.positions } }, 200, tenantId))
+      .filter((r) => grantAppliesInTenant(r.organization_id, tenantId));
     const deactivatedNames = new Set<string>(
       positionRows.filter((r) => !isRowActive(r)).map((r) => r.name).filter(Boolean),
     );
 
@@ -17,6 +17,11 @@
  * whole environment (200), and `DELETE /packages/:id` reached the door's own
  * organization check (400 `TENANT_SCOPE_REQUIRED`) instead of the gate's 403.
  *
+ * The same held for a set the left organization bound to one of its own
+ * POSITIONS: with no tenant the position read is installation-wide, so the left
+ * organization's copy of `org_member` fed its bindings to anyone still an
+ * `org_member` somewhere.
+ *
  * The rule now: with no active organization only the global grants apply, and
  * a grant scoped to an organization applies only while that organization is the
  * active tenant (`resolveUserAuthzGrants`, `@objectstack/core`).
@@ -75,8 +80,10 @@ const TABLES: Record<string, any[]> = {
         { user_id: 'u_exmember', organization_id: BETA, role: 'member' },
         { user_id: 'u_global', organization_id: BETA, role: 'member' },
         { user_id: 'u_admin', organization_id: ALPHA, role: 'owner' },
+        { user_id: 'u_posex', organization_id: BETA, role: 'member' },
+        { user_id: 'u_posmember', organization_id: ALPHA, role: 'member' },
     ],
-    sys_user: ['u_member', 'u_exmember', 'u_gone', 'u_global', 'u_admin']
+    sys_user: ['u_member', 'u_exmember', 'u_gone', 'u_global', 'u_admin', 'u_posex', 'u_posmember']
         .map((id) => ({ id, email: `${id}@example.com` })),
     sys_user_permission_set: [
         { user_id: 'u_member', permission_set_id: 'ps_meta', organization_id: ALPHA },
@@ -88,10 +95,22 @@ const TABLES: Record<string, any[]> = {
     sys_permission_set: [
         { id: 'ps_meta', name: 'alpha_metadata_editors', system_permissions: ['manage_metadata', 'studio.access'] },
         { id: 'ps_admin', name: 'admin_full_access', system_permissions: ['manage_metadata', 'studio.access', 'setup.access'] },
+        { id: 'ps_members', name: 'alpha_member_tools', system_permissions: ['manage_metadata'] },
+    ],
+    // The per-organization copies of the `org_member` built-in a walled catalog
+    // holds; org_alpha bound a metadata-editing set to ITS copy. This double
+    // ignores the read's tenant, which is exactly what an organization-less
+    // resolution's installation-wide `sys_position` read does.
+    sys_position: [
+        { id: 'pos_member_alpha', name: 'org_member', organization_id: ALPHA },
+        { id: 'pos_member_beta', name: 'org_member', organization_id: BETA },
+    ],
+    sys_position_permission_set: [
+        { position_id: 'pos_member_alpha', permission_set_id: 'ps_members' },
     ],
 };
 
-type Who = 'member' | 'exmember' | 'gone' | 'global' | 'admin' | 'admin_orgless';
+type Who = 'member' | 'exmember' | 'gone' | 'global' | 'admin' | 'admin_orgless' | 'posex' | 'posmember';
 
 /** Every session but the last names `org_alpha`. */
 const SESSIONS: Record<Who, { id: string; token: string; userId: string; activeOrganizationId?: string }> = {
@@ -101,6 +120,8 @@ const SESSIONS: Record<Who, { id: string; token: string; userId: string; activeO
     global: { id: 'ses_global', token: 'tok_global', userId: 'u_global', activeOrganizationId: ALPHA },
     admin: { id: 'ses_admin', token: 'tok_admin', userId: 'u_admin', activeOrganizationId: ALPHA },
     admin_orgless: { id: 'ses_admin2', token: 'tok_admin2', userId: 'u_admin' },
+    posex: { id: 'ses_posex', token: 'tok_posex', userId: 'u_posex', activeOrganizationId: ALPHA },
+    posmember: { id: 'ses_posmember', token: 'tok_posmember', userId: 'u_posmember', activeOrganizationId: ALPHA },
 };
 
 function rig() {
@@ -185,6 +206,9 @@ afterEach(() => { warnSpy.mockRestore(); });
 const REMOVED: Array<[Who, string]> = [
     ['exmember', 'a member removed from org_alpha, still a member of org_beta'],
     ['gone', 'a member removed from org_alpha, with no membership left anywhere'],
+    // The same set reached through a POSITION: org_alpha bound it to its own
+    // copy of `org_member`, and this member is still an `org_member` elsewhere.
+    ['posex', 'a member removed from org_alpha whose org_member binding there carried manage_metadata'],
 ];
 
 describe('[#20515] a removed member\'s organization-scoped manage_metadata no longer passes the /packages gate', () => {
@@ -225,6 +249,13 @@ describe('[#20515] what the rule leaves unchanged', () => {
         expect(r.deleteRequests).toEqual([{ packageId: PKG, organizationId: ALPHA }]);
     });
 
+    it('CONTROL · the position-bound set: a current org_alpha member with org_alpha active passes: 200', async () => {
+        const r = rig();
+        const answer = await r.call('DELETE', 'posmember', `/packages/${PKG}`);
+        expect(answer.status).toBe(200);
+        expect(r.deleteRequests).toEqual([{ packageId: PKG, organizationId: ALPHA }]);
+    });
+
     it('a GLOBAL grant still passes the gate for the removed member — the door\'s own organization check answers, not the gate', async () => {
         const r = rig();
         const answer = await r.call('DELETE', 'global', `/packages/${PKG}`);