diff --git a/common/config/rush/pnpm-lock.yaml b/common/config/rush/pnpm-lock.yaml
index 57a469ad1fa..e8383843775 100644
--- a/common/config/rush/pnpm-lock.yaml
+++ b/common/config/rush/pnpm-lock.yaml
@@ -18056,6 +18056,9 @@ importers:
       '@hcengineering/text':
         specifier: workspace:^0.7.19
         version: link:../../foundations/core/packages/text
+      '@hcengineering/text-core':
+        specifier: workspace:^0.7.19
+        version: link:../../foundations/core/packages/text-core
       '@hcengineering/text-editor':
         specifier: workspace:^0.7.0
         version: link:../text-editor
@@ -61713,7 +61716,7 @@ snapshots:
   node-loader@2.0.0(webpack@5.102.1):
     dependencies:
       loader-utils: 2.0.4
-      webpack: 5.102.1
+      webpack: 5.102.1(esbuild@0.25.12)(webpack-cli@5.1.4)
 
   node-localstorage@2.2.1:
     dependencies:
diff --git a/foundations/core/packages/core/src/__tests__/collaborators.test.ts b/foundations/core/packages/core/src/__tests__/collaborators.test.ts
index 3e69795765a..5b372a85c6b 100644
--- a/foundations/core/packages/core/src/__tests__/collaborators.test.ts
+++ b/foundations/core/packages/core/src/__tests__/collaborators.test.ts
@@ -13,11 +13,11 @@
 // limitations under the License.
 //
 
-import { getClassCollaborators } from '../collaborators'
+import { getClassCollaborators, resolveMentionGrantTarget } from '../collaborators'
 import { ModelDb } from '../memdb'
 import { Hierarchy } from '../hierarchy'
 import core from '../component'
-import type { Class, ClassCollaborators, Doc, Ref } from '../classes'
+import type { AttachedDoc, Class, ClassCollaborators, Doc, Ref } from '../classes'
 
 describe('collaborators', () => {
   let model: ModelDb
@@ -198,4 +198,109 @@ describe('collaborators', () => {
       expect(result).toBe(collab2)
     })
   })
+
+  describe('resolveMentionGrantTarget', () => {
+    const ISSUE = 'tracker:class:Issue' as Ref<Class<Doc>>
+    const THREAD = 'chunter:class:ThreadMessage' as Ref<Class<Doc>>
+    const MSG = 'chunter:class:ChatMessage' as Ref<Class<Doc>>
+
+    // Builds a findAll injector like the server/client pass in. `opted` is the
+    // set of _class refs whose ClassCollaborators is provideSecurity+mentionsGrantAccess.
+    // `docs` maps _id -> Doc for the attachedTo parent lookups.
+    function makeFindAll (
+      opted: Set<string>,
+      docs: Record<string, Doc>
+    ): jest.Mock<Promise<any[]>, [Ref<Class<Doc>>, any, any?]> {
+      return jest.fn(async (cls: Ref<Class<Doc>>, q: any, _options?: any) => {
+        if (cls === core.class.ClassCollaborators) {
+          const target = q.attachedTo as string
+          return opted.has(target) ? [{ provideSecurity: true, mentionsGrantAccess: true }] : []
+        }
+        const doc = docs[q._id as string]
+        return doc != null ? [doc] : []
+      })
+    }
+
+    it('returns the start doc when it is itself opted in', async () => {
+      const start: Doc = { _id: 'i1' as Ref<Doc>, _class: ISSUE } as unknown as Doc
+      const findAll = makeFindAll(new Set([ISSUE]), {})
+
+      const result = await resolveMentionGrantTarget(start, findAll)
+
+      expect(result).toBe(start)
+    })
+
+    it('walks the attachedTo chain to the first opted-in ancestor', async () => {
+      const issue: Doc = { _id: 'i1' as Ref<Doc>, _class: ISSUE } as unknown as Doc
+      const thread = {
+        _id: 'tm1' as Ref<Doc>,
+        _class: THREAD,
+        attachedTo: 'i1' as Ref<Doc>,
+        attachedToClass: ISSUE
+      } as unknown as AttachedDoc
+
+      // ThreadMessage + ChatMessage are NOT opted in; only the Issue ancestor is.
+      const findAll = makeFindAll(new Set([ISSUE]), { i1: issue })
+
+      const result = await resolveMentionGrantTarget(thread, findAll)
+
+      expect(result).toBe(issue)
+    })
+
+    it('returns null when nothing in the chain is opted in', async () => {
+      const parent = { _id: 'p1' as Ref<Doc>, _class: MSG } as unknown as Doc
+      const child = {
+        _id: 'c1' as Ref<Doc>,
+        _class: THREAD,
+        attachedTo: 'p1' as Ref<Doc>,
+        attachedToClass: MSG
+      } as unknown as AttachedDoc
+
+      const findAll = makeFindAll(new Set(), { p1: parent })
+
+      const result = await resolveMentionGrantTarget(child, findAll)
+
+      expect(result).toBeNull()
+    })
+
+    it('returns null on an attachedTo cycle (depth cap 8)', async () => {
+      // Self-referential doc: attachedTo points back at itself, never opted in.
+      const node = {
+        _id: 'x' as Ref<Doc>,
+        _class: THREAD,
+        attachedTo: 'x' as Ref<Doc>,
+        attachedToClass: THREAD
+      } as unknown as AttachedDoc
+      const findAll = makeFindAll(new Set(), { x: node as unknown as Doc })
+
+      const result = await resolveMentionGrantTarget(node, findAll)
+
+      expect(result).toBeNull()
+      // Depth cap 8: exactly 8 ClassCollaborators probes (one per loop turn).
+      const ccProbes = findAll.mock.calls.filter((c) => c[0] === core.class.ClassCollaborators)
+      expect(ccProbes.length).toBe(8)
+    })
+
+    it('passes { limit: 1 } as the third arg on every findAll lookup (fix guard)', async () => {
+      const issue: Doc = { _id: 'i1' as Ref<Doc>, _class: ISSUE } as unknown as Doc
+      const thread = {
+        _id: 'tm1' as Ref<Doc>,
+        _class: THREAD,
+        attachedTo: 'i1' as Ref<Doc>,
+        attachedToClass: ISSUE
+      } as unknown as AttachedDoc
+      const findAll = makeFindAll(new Set([ISSUE]), { i1: issue })
+
+      await resolveMentionGrantTarget(thread, findAll)
+
+      // Both the ClassCollaborators probe and the parent lookup must be bounded.
+      expect(findAll).toHaveBeenCalled()
+      for (const call of findAll.mock.calls) {
+        expect(call[2]).toEqual({ limit: 1 })
+      }
+      // Sanity: at least one ClassCollaborators probe and one parent lookup ran.
+      expect(findAll.mock.calls.some((c) => c[0] === core.class.ClassCollaborators)).toBe(true)
+      expect(findAll.mock.calls.some((c) => c[0] === ISSUE)).toBe(true)
+    })
+  })
 })
diff --git a/foundations/core/packages/core/src/classes.ts b/foundations/core/packages/core/src/classes.ts
index b9c62466d90..07a9baa37d0 100644
--- a/foundations/core/packages/core/src/classes.ts
+++ b/foundations/core/packages/core/src/classes.ts
@@ -1010,8 +1010,15 @@ export interface ClassCollaborators<T extends Doc> extends Doc {
   attachedTo: Ref<Class<T>>
   allFields?: boolean // for all (PersonId | Ref<Employee> | PersonId[] | Ref<Employee>[]) attributes
   fields: (keyof T)[] // PersonId | Ref<Employee> | PersonId[] | Ref<Employee>[]
-  provideSecurity?: boolean // If true, will provide security for collaborators
+  // If true, Collaborator status grants read visibility on the doc,
+  // bypassing space-membership. Writes are governed by the class's
+  // TxAccessLevel and any pre-commit middleware (see GuestPermissions).
+  provideSecurity?: boolean
   provideAttachedSecurity?: boolean // If true, will provide security for collaborators of attached doc
+  // If true, @-mentions in chat/activity messages on this doc auto-create
+  // Collaborator records (mention = explicit, disclosed grant). Has no
+  // effect unless provideSecurity is also true.
+  mentionsGrantAccess?: boolean
 }
 
 export interface Collaborator extends AttachedDoc {
diff --git a/foundations/core/packages/core/src/collaborators.ts b/foundations/core/packages/core/src/collaborators.ts
index 1574a2c1401..1c516803783 100644
--- a/foundations/core/packages/core/src/collaborators.ts
+++ b/foundations/core/packages/core/src/collaborators.ts
@@ -13,7 +13,17 @@
 // limitations under the License.
 //
 
-import core, { Class, ClassCollaborators, Doc, Hierarchy, ModelDb, Ref } from '.'
+import core, {
+  AttachedDoc,
+  Class,
+  ClassCollaborators,
+  Doc,
+  DocumentQuery,
+  FindOptions,
+  Hierarchy,
+  ModelDb,
+  Ref
+} from '.'
 
 export function getClassCollaborators<T extends Doc> (
   model: ModelDb,
@@ -35,3 +45,51 @@ export function getClassCollaborators<T extends Doc> (
     }
   }
 }
+
+/**
+ * Walk a Doc's attachedTo chain to find the nearest ancestor (including the
+ * Doc itself) whose ClassCollaborators has BOTH provideSecurity===true AND
+ * mentionsGrantAccess===true. Returns that ancestor Doc as the grant target,
+ * or null if no such class is reached within the depth cap.
+ *
+ * Used by both the chunter mention-trigger (server) and the warning popup
+ * (client) so the disclosure UX matches the actual server-side grant. The
+ * helper is isomorphic via the findAll dependency injection — server passes
+ * `(cls, q, o) => control.findAll(control.ctx, cls, q, o)`, client passes
+ * `(cls, q, o) => getClient().findAll(cls, q, o)`.
+ *
+ * The ClassCollaborators lookup is exact-class (not inherited via ancestors)
+ * — adequate for tracker.class.Issue and avoids surprising matches on
+ * abstract base classes like AttachedDoc. If future opt-in classes need
+ * inherited semantics, switch to `getClassCollaborators(model, hierarchy, _class)`
+ * here (requires plumbing ModelDb + Hierarchy through the dependency
+ * injection — kept out for now to keep the helper isomorphic without
+ * the ModelDb tax on the client).
+ *
+ * Depth cap (8) defends against pathological attachedTo cycles.
+ */
+export async function resolveMentionGrantTarget (
+  start: Doc,
+  findAll: <T extends Doc>(cls: Ref<Class<T>>, q: DocumentQuery<T>, options?: FindOptions<T>) => Promise<T[]>
+): Promise<Doc | null> {
+  let cur: Doc | undefined = start
+  for (let i = 0; i < 8 && cur != null; i++) {
+    const ccQuery: DocumentQuery<ClassCollaborators<Doc>> = {
+      attachedTo: cur._class
+    }
+    const cc = (await findAll(core.class.ClassCollaborators, ccQuery, { limit: 1 }))[0]
+    if (cc?.provideSecurity === true && cc.mentionsGrantAccess === true) {
+      return cur
+    }
+    const attached = cur as AttachedDoc
+    if (attached.attachedTo == null || attached.attachedToClass == null) {
+      return null
+    }
+    const parentQuery: DocumentQuery<Doc> = {
+      _id: attached.attachedTo
+    }
+    const parent = (await findAll(attached.attachedToClass, parentQuery, { limit: 1 }))[0]
+    cur = parent
+  }
+  return null
+}
diff --git a/foundations/core/packages/text-core/src/markup/__tests__/reference.test.ts b/foundations/core/packages/text-core/src/markup/__tests__/reference.test.ts
new file mode 100644
index 00000000000..167ac76e1cf
--- /dev/null
+++ b/foundations/core/packages/text-core/src/markup/__tests__/reference.test.ts
@@ -0,0 +1,74 @@
+import { extractReferences } from '../reference'
+import { MarkupNodeType, type MarkupNode } from '../model'
+
+function refNode (id: string, label: string, objectclass: string, grantsAccess?: 'true' | 'false'): MarkupNode {
+  return {
+    type: MarkupNodeType.reference,
+    attrs: { id, label, objectclass, ...(grantsAccess !== undefined ? { grantsAccess } : {}) }
+  }
+}
+
+function doc (...children: MarkupNode[]): MarkupNode {
+  return { type: MarkupNodeType.doc, content: children }
+}
+
+describe('extractReferences grantsAccess', () => {
+  test('surfaces grantsAccess from a reference node', () => {
+    const refs = extractReferences(doc(refNode('p1', 'Alice', 'contact:class:Person', 'true')))
+    expect(refs).toHaveLength(1)
+    expect(refs[0].objectId).toBe('p1')
+    expect(refs[0].grantsAccess).toBe('true')
+  })
+
+  test('grantsAccess undefined when attr absent (default = grant)', () => {
+    const refs = extractReferences(doc(refNode('p1', 'Alice', 'contact:class:Person')))
+    expect(refs[0].grantsAccess).toBeUndefined()
+  })
+
+  test('any-wins: false then true => true', () => {
+    const refs = extractReferences(
+      doc(
+        refNode('p1', 'Alice', 'contact:class:Person', 'false'),
+        refNode('p1', 'Alice', 'contact:class:Person', 'true')
+      )
+    )
+    expect(refs).toHaveLength(1)
+    expect(refs[0].grantsAccess).toBe('true')
+  })
+
+  test('any-wins: true then false => true', () => {
+    const refs = extractReferences(
+      doc(
+        refNode('p1', 'Alice', 'contact:class:Person', 'true'),
+        refNode('p1', 'Alice', 'contact:class:Person', 'false')
+      )
+    )
+    expect(refs[0].grantsAccess).toBe('true')
+  })
+
+  test('any-wins: false then undefined => not false (undefined grants)', () => {
+    const refs = extractReferences(
+      doc(refNode('p1', 'Alice', 'contact:class:Person', 'false'), refNode('p1', 'Alice', 'contact:class:Person'))
+    )
+    expect(refs[0].grantsAccess).not.toBe('false')
+  })
+
+  test('all explicitly false => false', () => {
+    const refs = extractReferences(
+      doc(
+        refNode('p1', 'Alice', 'contact:class:Person', 'false'),
+        refNode('p1', 'Alice', 'contact:class:Person', 'false')
+      )
+    )
+    expect(refs[0].grantsAccess).toBe('false')
+  })
+
+  test('different persons kept separate', () => {
+    const refs = extractReferences(
+      doc(refNode('p1', 'Alice', 'contact:class:Person', 'true'), refNode('p2', 'Bob', 'contact:class:Person', 'false'))
+    )
+    expect(refs).toHaveLength(2)
+    expect(refs.find((r) => r.objectId === 'p1')?.grantsAccess).toBe('true')
+    expect(refs.find((r) => r.objectId === 'p2')?.grantsAccess).toBe('false')
+  })
+})
diff --git a/foundations/core/packages/text-core/src/markup/model.ts b/foundations/core/packages/text-core/src/markup/model.ts
index 9b275c14f0c..cc5b581914a 100644
--- a/foundations/core/packages/text-core/src/markup/model.ts
+++ b/foundations/core/packages/text-core/src/markup/model.ts
@@ -93,5 +93,11 @@ export interface LinkMark extends MarkupMark {
 /** @public */
 export interface ReferenceMarkupNode extends MarkupNode {
   type: MarkupNodeType.reference
-  attrs: { id: string, label: string, objectclass: string }
+  /**
+   * grantsAccess (V3): when 'false', the chunter mention-grants trigger skips
+   * Collaborator creation for this mention. undefined means "grant" (default,
+   * preserves pre-V3 behaviour). Stored as a string because markup attrs
+   * serialize through HTML where boolean coercion is unreliable.
+   */
+  attrs: { id: string, label: string, objectclass: string, grantsAccess?: 'true' | 'false' }
 }
diff --git a/foundations/core/packages/text-core/src/markup/reference.ts b/foundations/core/packages/text-core/src/markup/reference.ts
index a9e4c64261a..cccf9f35025 100644
--- a/foundations/core/packages/text-core/src/markup/reference.ts
+++ b/foundations/core/packages/text-core/src/markup/reference.ts
@@ -24,6 +24,9 @@ export interface Reference {
   objectId: Ref<Doc>
   objectClass: Ref<Class<Doc>>
   parentNode: MarkupNode | null
+  // V3: undefined = grant (default); 'false' = explicit deny. Merged any-wins
+  // across duplicate references to the same object (see extractReferences).
+  grantsAccess?: 'true' | 'false'
 }
 
 /**
@@ -37,9 +40,19 @@ export function extractReferences (content: MarkupNode): Array<Reference> {
       const reference = node as ReferenceMarkupNode
       const objectId = reference.attrs.id as Ref<Doc>
       const objectClass = reference.attrs.objectclass as Ref<Class<Doc>>
+      const grantsAccess = reference.attrs.grantsAccess
       const e = result.find((e) => e.objectId === objectId && e.objectClass === objectClass)
       if (e === undefined) {
-        result.push({ objectId, objectClass, parentNode: parent ?? node })
+        result.push({ objectId, objectClass, parentNode: parent ?? node, grantsAccess })
+      } else {
+        // any-wins: a person is denied only if EVERY reference is explicitly
+        // 'false'. Upgrade away from 'false' as soon as a non-'false' (grant
+        // or default) reference appears; upgrade default->'true' cosmetically.
+        if (e.grantsAccess === 'false' && grantsAccess !== 'false') {
+          e.grantsAccess = grantsAccess
+        } else if (e.grantsAccess === undefined && grantsAccess === 'true') {
+          e.grantsAccess = 'true'
+        }
       }
     }
     return true
diff --git a/foundations/core/packages/text/src/nodes/reference.ts b/foundations/core/packages/text/src/nodes/reference.ts
index 8a9bbf685ab..02fa7240df5 100644
--- a/foundations/core/packages/text/src/nodes/reference.ts
+++ b/foundations/core/packages/text/src/nodes/reference.ts
@@ -22,6 +22,7 @@ export interface ReferenceNodeProps {
   id: Ref<Doc>
   objectclass: Ref<Class<Doc>>
   label: string
+  grantsAccess?: 'true' | 'false'
   fixed?: boolean
 }
 
@@ -44,6 +45,17 @@ export const ReferenceNode = Node.create<ReferenceOptions>({
       id: getDataAttribute('id'),
       objectclass: getDataAttribute('objectclass'),
       label: getDataAttribute('label'),
+      grantsAccess: {
+        // V3: keep the deny flag across edit round-trips. parseHTML normalises
+        // a missing attribute to `undefined` rather than `null` so the runtime
+        // value matches the public type `'true' | 'false' | undefined` declared
+        // on ReferenceMarkupNode.attrs — a `null` would break strict
+        // `=== undefined` checks downstream.
+        default: undefined,
+        parseHTML: (element) => element.getAttribute('data-grants-access') ?? undefined,
+        renderHTML: (attributes) =>
+          attributes.grantsAccess == null ? null : { 'data-grants-access': attributes.grantsAccess }
+      },
       fixed: {
         default: null,
         parseHTML: (element) => element.getAttribute('data-fixed') === 'true',
@@ -90,6 +102,11 @@ export const ReferenceNode = Node.create<ReferenceOptions>({
           'data-id': node.attrs.id,
           'data-objectclass': node.attrs.objectclass,
           'data-label': node.attrs.label,
+          // V3: belt-and-suspenders — explicitly emit data-grants-access here
+          // (in addition to the per-attribute renderHTML in addAttributes) so
+          // the deny flag is rendered even if the attribute-renderer merge
+          // path is bypassed by a downstream override.
+          ...(node.attrs.grantsAccess != null ? { 'data-grants-access': node.attrs.grantsAccess } : {}),
           class: 'antiMention'
         },
         this.options.HTMLAttributes,
@@ -110,10 +127,13 @@ function getAttrs (el: HTMLSpanElement): Attrs | false {
     return false
   }
 
+  const grantsAccess = el.dataset.grantsAccess
+
   return {
     id,
     label,
     objectclass,
+    ...(grantsAccess !== undefined ? { grantsAccess } : {}),
     fixed: fixed || null
   }
 }
diff --git a/foundations/server/packages/core/src/adapter.ts b/foundations/server/packages/core/src/adapter.ts
index 89776f06fbf..0c27a3c0c31 100644
--- a/foundations/server/packages/core/src/adapter.ts
+++ b/foundations/server/packages/core/src/adapter.ts
@@ -70,6 +70,18 @@ export interface RawFindIterator {
  * @public
  */
 export interface DbAdapter extends LowLevelStorage {
+  // Backend capability flag. When true, this adapter enforces collaborator-grant
+  // read security at the storage layer (e.g. the Postgres addSecurity collab
+  // OR-branch that joins the Collaborator domain into the visibility check).
+  //
+  // The space-security middleware only drops the space filter for collab-read
+  // bypasses (Guests reading docs they collaborate on, Collaborator self-reads,
+  // collab-only space listing) when the adapter serving the domain sets this to
+  // true. Absent/false is treated as fail-closed: the middleware keeps the normal
+  // space filter, so a backend without an equivalent clause (e.g. Mongo, which has
+  // no adapter-side space security) cannot leak docs across spaces.
+  supportsCollaboratorSecurity?: boolean
+
   init?: (
     ctx: MeasureContext,
     contextVars: Record<string, any>,
diff --git a/foundations/server/packages/middleware/src/guestPermissions.ts b/foundations/server/packages/middleware/src/guestPermissions.ts
index 077d546a84d..506bd8a30ce 100644
--- a/foundations/server/packages/middleware/src/guestPermissions.ts
+++ b/foundations/server/packages/middleware/src/guestPermissions.ts
@@ -10,6 +10,7 @@ import core, {
   type Class,
   type Doc,
   type ClassPermission,
+  getClassCollaborators,
   type Permission,
   hasAccountRole,
   type MeasureContext,
@@ -157,9 +158,57 @@ export class GuestPermissionsMiddleware extends BaseMiddleware implements Middle
       } else if (cudTx.space !== core.space.DerivedTx && (await this.isForbiddenTx(ctx, cudTx, account))) {
         throw new PlatformError(new Status(Severity.ERROR, platform.status.Forbidden, {}))
       }
+      if (await this.isForbiddenCollabOnlyGuestFieldUpdate(ctx, cudTx, account)) {
+        throw new PlatformError(new Status(Severity.ERROR, platform.status.Forbidden, {}))
+      }
     }
   }
 
+  /**
+   * Class-agnostic veto for field updates on docs whose class has opted into
+   * mention-grants-access. The opt-in is the pair (provideSecurity: true,
+   * mentionsGrantAccess: true) on the class's ClassCollaborators model entry.
+   *
+   * For such classes, a guest-tier account that obtained read visibility ONLY
+   * through Collaborator status (i.e. is NOT in the doc's space.members) must
+   * not be able to modify the doc's fields via TxUpdateDoc NOR delete it via
+   * TxRemoveDoc (L-RM). Comments via chunter.class.ChatMessage createAccessLevel
+   * still pass through.
+   *
+   * Space-member guests retain their current behavior — they pass through
+   * this check untouched and their normal access rules continue to apply.
+   * User+ accounts always pass through.
+   *
+   * If the class has not opted in, this veto is a no-op (returns false).
+   */
+  private async isForbiddenCollabOnlyGuestFieldUpdate (
+    ctx: MeasureContext<SessionData>,
+    cudTx: TxCUD<Doc>,
+    account: Account
+  ): Promise<boolean> {
+    // L-RM: veto covers both field-updates AND removes by collab-only guests.
+    if (cudTx._class !== core.class.TxUpdateDoc && cudTx._class !== core.class.TxRemoveDoc) return false
+
+    const isGuest =
+      account.role === AccountRole.Guest ||
+      account.role === AccountRole.DocGuest ||
+      account.role === AccountRole.ReadOnlyGuest
+    if (!isGuest) return false
+
+    const classCollab = getClassCollaborators(this.context.modelDb, this.context.hierarchy, cudTx.objectClass)
+    if (classCollab?.provideSecurity !== true) return false
+    if (classCollab.mentionsGrantAccess !== true) return false
+
+    const space = (await this.findAll<Space>(ctx, core.class.Space, { _id: cudTx.objectSpace }))[0]
+    // L-GP: fail-closed — if the doc's space cannot be resolved we cannot prove
+    // the caller is a space member, so the collab-only-guest veto must FORBID
+    // (previously returned false = fail-open = mutation allowed).
+    if (space === undefined) return true
+    if (space.members?.includes(account.uuid)) return false
+
+    return true
+  }
+
   /**
    * Returns the covered-class ancestor of the objectClass if one exists in the new permissions model,
    * or undefined if the class is not covered.
diff --git a/foundations/server/packages/middleware/src/spaceSecurity.ts b/foundations/server/packages/middleware/src/spaceSecurity.ts
index 4c8bd4223e1..2fafe0203b9 100644
--- a/foundations/server/packages/middleware/src/spaceSecurity.ts
+++ b/foundations/server/packages/middleware/src/spaceSecurity.ts
@@ -613,6 +613,27 @@ export class SpaceSecurityMiddleware extends BaseMiddleware implements Middlewar
     return domain === 'tx' ? 'objectSpace' : domain === 'space' ? '_id' : 'space'
   }
 
+  // H5 (Option A, fail-closed): the collab-read bypasses in findAll drop the space
+  // filter and delegate the restriction to the adapter's collab OR-branch, which
+  // only exists in the Postgres adapter (see postgres/src/storage.ts addSecurity).
+  // On a backend without an equivalent clause (e.g. Mongo) dropping the space
+  // filter would leak docs across spaces. So the bypasses may only fire when the
+  // adapter serving this domain declares supportsCollaboratorSecurity. Unknown or
+  // unsupported backend => false => keep the normal space filter (no leak; the
+  // cross-space collab feature is simply inactive there).
+  private isCollabBackendSupported (domain: Domain): boolean {
+    const mgr = this.context.adapterManager
+    if (mgr === undefined) {
+      return false
+    }
+    try {
+      const adapter = mgr.getAdapterByName(mgr.getAdapterName(domain), false)
+      return adapter?.supportsCollaboratorSecurity === true
+    } catch {
+      return false
+    }
+  }
+
   override async findAll<T extends Doc>(
     ctx: MeasureContext<SessionData>,
     _class: Ref<Class<T>>,
@@ -630,7 +651,46 @@ export class SpaceSecurityMiddleware extends BaseMiddleware implements Middlewar
 
     let clientFilterSpaces: Set<Ref<Space>> | undefined
 
-    if (!isSystem(account, ctx) && account.role !== AccountRole.DocGuest && domain !== DOMAIN_MODEL) {
+    // When a class opts into collaborator-grants-read security AND the caller is a Guest/ReadOnlyGuest,
+    // we deliberately skip the middleware-level space filter. The Postgres adapter's `collabRes`
+    // OR-branch (see postgres/src/storage.ts, getSecurityClause) joins Collaborator records into the
+    // visibility check, so Guests can read individual docs they were added to as Collaborator even
+    // when they are not members of the owning Space. Filtering by space here would strip those docs
+    // before the adapter ever sees the query.
+    const collabSec =
+      domain !== DOMAIN_MODEL ? getClassCollaborators(this.context.modelDb, this.context.hierarchy, _class) : undefined
+    // H5 (fail-closed): a collab-read bypass drops the space filter and relies on
+    // the adapter's collab OR-branch to re-restrict visibility. That branch only
+    // exists on backends that declare supportsCollaboratorSecurity (Postgres /
+    // CockroachDB). On any other backend the bypass would leak across spaces, so we
+    // gate all three bypasses behind this single check. Unknown backend => false =>
+    // the normal space filter stays in place.
+    const collabBackendSupported = domain !== DOMAIN_MODEL && this.isCollabBackendSupported(domain)
+    const collabReadBypass =
+      collabBackendSupported &&
+      (collabSec?.provideSecurity === true || collabSec?.provideAttachedSecurity === true) &&
+      [AccountRole.Guest, AccountRole.ReadOnlyGuest].includes(account.role)
+    // Self-Collaborator visibility: let the Postgres adapter's self-collab OR-branch
+    // (storage.ts, addSecurity) fire for any non-System caller when reading the
+    // Collaborator class itself. Required for queries like the tracker "Subscribed"
+    // tab `{collaborator: self, attachedToClass: Issue}`, which must surface the
+    // user's own subscriptions even on docs in non-member spaces.
+    const selfCollabBypass = collabBackendSupported && this.context.hierarchy.isDerived(_class, core.class.Collaborator)
+    // Containing-Space visibility for collab-only Guests: let the Postgres adapter's
+    // space-collab OR-branch surface Spaces that host docs the caller is a
+    // Collaborator on. Required so the project/space nav tree can list projects
+    // where the user is collab-only (no member status).
+    const spaceCollabBypass =
+      collabBackendSupported && isSpace && [AccountRole.Guest, AccountRole.ReadOnlyGuest].includes(account.role)
+
+    if (
+      !isSystem(account, ctx) &&
+      account.role !== AccountRole.DocGuest &&
+      domain !== DOMAIN_MODEL &&
+      !collabReadBypass &&
+      !selfCollabBypass &&
+      !spaceCollabBypass
+    ) {
       if (!isOwner(account, ctx) || !isSpace || !showArchived) {
         if (newQuery[field] !== undefined) {
           const res = await this.mergeQuery(ctx, account, newQuery[field], domain, isSpace, showArchived)
diff --git a/foundations/server/packages/middleware/src/tests/collabSpaceSecurity.test.ts b/foundations/server/packages/middleware/src/tests/collabSpaceSecurity.test.ts
new file mode 100644
index 00000000000..7c8d86ae4b9
--- /dev/null
+++ b/foundations/server/packages/middleware/src/tests/collabSpaceSecurity.test.ts
@@ -0,0 +1,254 @@
+//
+// Copyright © 2025 Hardcore Engineering Inc.
+//
+// Licensed under the Eclipse Public License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License. You may
+// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/**
+ * H5 - Collab-read bypass must be backend-guarded (fail-closed).
+ *
+ * The three collab-read bypasses in SpaceSecurityMiddleware.findAll drop the
+ * space filter and delegate the restriction to the adapter's collab OR-branch,
+ * which only exists in the Postgres adapter (postgres/src/storage.ts addSecurity).
+ * On a backend without an equivalent clause (Mongo has none) dropping the space
+ * filter would leak docs across spaces.
+ *
+ * These tests drive findAll with a mocked pipeline and capture the query that
+ * leaves the middleware towards the adapter:
+ *  - backend supports collab security  -> bypass fires  -> space filter dropped
+ *  - backend does NOT (Mongo/unknown)  -> bypass skipped -> space filter kept
+ */
+
+import core, {
+  AccountRole,
+  generateId,
+  MeasureMetricsContext,
+  toFindResult,
+  type Account,
+  type Class,
+  type Doc,
+  type Domain,
+  type MeasureContext,
+  type PersonId,
+  type Ref,
+  type SessionData,
+  type Space
+} from '@hcengineering/core'
+import type { PipelineContext } from '@hcengineering/server-core'
+import { SpaceSecurityMiddleware } from '../spaceSecurity'
+
+const ISSUE_CLASS = 'test:class:Issue' as Ref<Class<Doc>>
+const ISSUE_DOMAIN = 'test-issue' as Domain
+const SPACE_CLASS = core.class.Space
+const COLLAB_CLASS = core.class.Collaborator
+
+const S1 = 'test:space:S1' as Ref<Space> // guest IS a member
+const S2 = 'test:space:S2' as Ref<Space> // guest is NOT a member (collab-only)
+
+function makeGuest (): Account {
+  return {
+    uuid: generateId() as any,
+    role: AccountRole.Guest,
+    primarySocialId: 'test' as PersonId,
+    socialIds: ['test' as PersonId],
+    fullSocialIds: []
+  }
+}
+
+function makeCtx (account: Account): MeasureContext<SessionData> {
+  const ctx = new MeasureMetricsContext('test', {}) as MeasureContext<SessionData>
+  ctx.contextData = {
+    account,
+    socialStringsToUsers: new Map(),
+    broadcast: { txes: [], queue: [], sessions: {} }
+  } as any
+  return ctx
+}
+
+interface Captured {
+  query?: any
+}
+
+function admittedSpaces (filterValue: any): Array<Ref<Space>> {
+  if (filterValue === undefined) return []
+  if (typeof filterValue === 'object' && Array.isArray(filterValue.$in)) return filterValue.$in
+  return [filterValue]
+}
+
+/**
+ * Build a SpaceSecurityMiddleware wired to a mocked pipeline.
+ *
+ * backendSupportsCollab: whether the adapter serving the domain declares
+ *   supportsCollaboratorSecurity (true = Postgres-like, false = Mongo-like).
+ * noAdapterManager: simulate a pipeline without an adapter manager.
+ * provideSecurity: whether the queried class opts into collab read security.
+ * derivedFromSpace / derivedFromCollaborator: how `_class` reports isDerived.
+ */
+function makeMiddleware (opts: {
+  backendSupportsCollab?: boolean
+  noAdapterManager?: boolean
+  provideSecurity?: boolean
+  derivedFromSpace?: boolean
+  derivedFromCollaborator?: boolean
+}): { mw: SpaceSecurityMiddleware, captured: Captured } {
+  const captured: Captured = {}
+
+  const collabConfig = opts.provideSecurity === true ? [{ attachedTo: ISSUE_CLASS, provideSecurity: true } as any] : []
+
+  const hierarchy = {
+    getDomain: (_class: Ref<Class<Doc>>): Domain => {
+      if (_class === SPACE_CLASS) return 'space' as Domain
+      if (_class === COLLAB_CLASS) return 'collaborator' as Domain
+      return ISSUE_DOMAIN
+    },
+    isDerived: (a: Ref<Class<Doc>>, b: Ref<Class<Doc>>): boolean => {
+      if (b === core.class.Space) return opts.derivedFromSpace === true
+      if (b === core.class.Collaborator) return opts.derivedFromCollaborator === true
+      return a === b
+    },
+    getAncestors: (_class: Ref<Class<Doc>>): Array<Ref<Class<Doc>>> => [_class]
+  }
+
+  const modelDb = {
+    findAllSync: (_class: Ref<Class<Doc>>): any[] => {
+      if (_class === core.class.ClassCollaborators) return collabConfig
+      return []
+    }
+  }
+
+  const adapterManager =
+    opts.noAdapterManager === true
+      ? undefined
+      : {
+          getAdapterName: (_domain: Domain): string => 'default',
+          getAdapterByName: (_name: string): any => ({
+            supportsCollaboratorSecurity: opts.backendSupportsCollab === true ? true : undefined
+          })
+        }
+
+  const context = {
+    workspace: { uuid: 'test-workspace' as any, url: 'test', dataId: 'test' as any },
+    hierarchy,
+    modelDb,
+    branding: null,
+    adapterManager,
+    contextVars: {}
+  } as unknown as PipelineContext
+
+  const next = {
+    findAll: async (_ctx: MeasureContext, _class: Ref<Class<Doc>>, query: any) => {
+      captured.query = query
+      return toFindResult([])
+    },
+    // Domain spaces for the queried domain: S1 and S2 both host docs.
+    groupBy: async () =>
+      new Map<Ref<Space>, number>([
+        [S1, 1],
+        [S2, 1]
+      ])
+  }
+
+  const mw = new (SpaceSecurityMiddleware as any)(false, context, next)
+  // Skip async init (would call next.findAll for Space); we seed state directly.
+  mw.wasInit = true
+
+  return { mw, captured }
+}
+
+describe('SpaceSecurityMiddleware - collab-read backend guard (H5)', () => {
+  describe('collabReadBypass (Guest reading a collab-secured Doc class)', () => {
+    it('Mongo/unknown backend: does NOT drop the space filter (fail-closed, no cross-space leak)', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: false, provideSecurity: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] } // member of S1 only
+
+      await mw.findAll(makeCtx(account), ISSUE_CLASS, {})
+
+      // Space filter must be present and must NOT admit S2 (the collab-only space).
+      expect(captured.query.space).toBeDefined()
+      const admitted = admittedSpaces(captured.query.space)
+      expect(admitted).not.toContain(S2)
+      expect(admitted).toContain(S1)
+    })
+
+    it('Postgres backend: drops the space filter so the adapter collab-branch can widen visibility', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: true, provideSecurity: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), ISSUE_CLASS, {})
+
+      // Bypass fired: no middleware-level space filter (adapter enforces collab security).
+      expect(captured.query.space).toBeUndefined()
+    })
+  })
+
+  describe('selfCollabBypass (reading the Collaborator class)', () => {
+    it('Mongo/unknown backend: keeps the space filter', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: false, derivedFromCollaborator: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), COLLAB_CLASS, {})
+
+      expect(captured.query.space).toBeDefined()
+      expect(admittedSpaces(captured.query.space)).not.toContain(S2)
+    })
+
+    it('Postgres backend: drops the space filter', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: true, derivedFromCollaborator: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), COLLAB_CLASS, {})
+
+      expect(captured.query.space).toBeUndefined()
+    })
+  })
+
+  describe('spaceCollabBypass (Guest listing Spaces)', () => {
+    it('Mongo/unknown backend: keeps the _id space filter', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: false, derivedFromSpace: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), SPACE_CLASS, {})
+
+      // For the space domain the filter field is `_id`.
+      expect(captured.query._id).toBeDefined()
+      expect(admittedSpaces(captured.query._id)).not.toContain(S2)
+    })
+
+    it('Postgres backend: drops the _id space filter', async () => {
+      const { mw, captured } = makeMiddleware({ backendSupportsCollab: true, derivedFromSpace: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), SPACE_CLASS, {})
+
+      expect(captured.query._id).toBeUndefined()
+    })
+  })
+
+  describe('fail-closed when no adapterManager is available', () => {
+    it('keeps the space filter even for a collab-secured class', async () => {
+      const { mw, captured } = makeMiddleware({ noAdapterManager: true, provideSecurity: true })
+      const account = makeGuest()
+      ;(mw as any).allowedSpaces = { [account.uuid]: [S1] }
+
+      await mw.findAll(makeCtx(account), ISSUE_CLASS, {})
+
+      expect(captured.query.space).toBeDefined()
+      expect(admittedSpaces(captured.query.space)).not.toContain(S2)
+    })
+  })
+})
diff --git a/foundations/server/packages/middleware/src/tests/guestPermissions.test.ts b/foundations/server/packages/middleware/src/tests/guestPermissions.test.ts
index e124aee8cbe..50464ddd8ff 100644
--- a/foundations/server/packages/middleware/src/tests/guestPermissions.test.ts
+++ b/foundations/server/packages/middleware/src/tests/guestPermissions.test.ts
@@ -192,6 +192,7 @@ describe('GuestPermissionsMiddleware', () => {
         return a === b
       }
       ;(mw as any).context.hierarchy.classHierarchyMixin = () => undefined
+      ;(mw as any).context.hierarchy.getAncestors = () => []
     }
 
     it('allows create for covered class in any space (TxAccessLevel is irrelevant)', async () => {
@@ -276,6 +277,7 @@ describe('GuestPermissionsMiddleware', () => {
         if (b === core.class.Space) return false
         return a === b
       }
+      ;(mw as any).context.hierarchy.getAncestors = () => []
 
       const tx = makeCreateTx(UNCOVERED_CLASS, ALLOWED_SPACE)
       const ctx = makeCtx(makeAccount(AccountRole.Guest))
@@ -310,6 +312,7 @@ describe('GuestPermissionsMiddleware', () => {
         if (b === core.class.Space) return false
         return a === b
       }
+      ;(mw as any).context.hierarchy.getAncestors = () => []
 
       const tx = makeCreateTx(COVERED_CLASS, ALLOWED_SPACE)
       const ctx = makeCtx(makeAccount(AccountRole.Guest))
@@ -337,6 +340,7 @@ describe('GuestPermissionsMiddleware', () => {
         if (b === core.class.Space) return false
         return a === b
       }
+      ;(mw as any).context.hierarchy.getAncestors = () => []
 
       const tx = makeCreateTx(COVERED_CLASS, FORBIDDEN_SPACE)
       const ctx = makeCtx(makeAccount(AccountRole.Guest))
@@ -364,6 +368,7 @@ describe('GuestPermissionsMiddleware', () => {
         if (b === core.class.Space) return false
         return a === b
       }
+      ;(mw as any).context.hierarchy.getAncestors = () => []
     }
 
     it('allows guest to update document created by same account', async () => {
@@ -468,6 +473,7 @@ describe('GuestPermissionsMiddleware', () => {
         return a === b
       }
       ;(mw as any).context.hierarchy.classHierarchyMixin = () => undefined
+      ;(mw as any).context.hierarchy.getAncestors = () => []
 
       // First tx as guest should load cache
       const userCtx = makeCtx(makeAccount(AccountRole.User))
@@ -488,4 +494,66 @@ describe('GuestPermissionsMiddleware', () => {
       expect((mw as any).permissionsCache).toBeUndefined()
     })
   })
+
+  // ─── collab-only guest veto: fail-closed (L-GP) + covers remove (L-RM) ────────
+  describe('collab-only guest veto (mention-grants opt-in)', () => {
+    const ISSUE_CLASS = 'test:class:Issue' as Ref<Class<Doc>>
+    const ISSUE_SPACE = 'test:space:Issue' as Ref<Space>
+
+    // Build a middleware whose model opts ISSUE_CLASS into mention-grants
+    // (provideSecurity + mentionsGrantAccess). `space` controls what findAll
+    // returns for the doc's space (undefined => unresolvable).
+    function makeCollabMw (space: Space | undefined): GuestPermissionsMiddleware {
+      const mw = makeMiddleware(async (_ctx, _class) => (space !== undefined ? [space] : []))
+      ;(mw as any).context.hierarchy.getAncestors = (id: any) => [id]
+      ;(mw as any).context.hierarchy.isDerived = (a: any, b: any) => a === b
+      ;(mw as any).context.hierarchy.classHierarchyMixin = () => undefined
+      ;(mw as any).context.modelDb = {
+        findAllSync: (_class: any, _q: any) => [
+          { attachedTo: ISSUE_CLASS, provideSecurity: true, mentionsGrantAccess: true }
+        ]
+      }
+      return mw
+    }
+
+    function makeSpace (members: any[]): Space {
+      return { _id: ISSUE_SPACE, members } as any
+    }
+
+    it('L-GP: fail-closed — unresolvable space forbids a guest field update', async () => {
+      const mw = makeCollabMw(undefined)
+      const guest = makeAccount(AccountRole.Guest)
+      const factory = new TxFactory('test:account:System' as PersonId)
+      const tx = factory.createTxUpdateDoc(ISSUE_CLASS, ISSUE_SPACE, generateId() as any, {})
+      const forbidden = await (mw as any).isForbiddenCollabOnlyGuestFieldUpdate(makeCtx(guest), tx, guest)
+      expect(forbidden).toBe(true)
+    })
+
+    it('L-RM: collab-only guest TxRemoveDoc on opted-in doc is forbidden', async () => {
+      const guest = makeAccount(AccountRole.Guest)
+      const mw = makeCollabMw(makeSpace([])) // guest is NOT a space member
+      const factory = new TxFactory('test:account:System' as PersonId)
+      const tx = factory.createTxRemoveDoc(ISSUE_CLASS, ISSUE_SPACE, generateId() as any)
+      const forbidden = await (mw as any).isForbiddenCollabOnlyGuestFieldUpdate(makeCtx(guest), tx, guest)
+      expect(forbidden).toBe(true)
+    })
+
+    it('space-member guest is NOT vetoed (update stays allowed)', async () => {
+      const guest = makeAccount(AccountRole.Guest)
+      const mw = makeCollabMw(makeSpace([guest.uuid]))
+      const factory = new TxFactory('test:account:System' as PersonId)
+      const tx = factory.createTxUpdateDoc(ISSUE_CLASS, ISSUE_SPACE, generateId() as any, {})
+      const forbidden = await (mw as any).isForbiddenCollabOnlyGuestFieldUpdate(makeCtx(guest), tx, guest)
+      expect(forbidden).toBe(false)
+    })
+
+    it('non-guest (User) TxRemoveDoc passes the veto', async () => {
+      const user = makeAccount(AccountRole.User)
+      const mw = makeCollabMw(makeSpace([]))
+      const factory = new TxFactory('test:account:System' as PersonId)
+      const tx = factory.createTxRemoveDoc(ISSUE_CLASS, ISSUE_SPACE, generateId() as any)
+      const forbidden = await (mw as any).isForbiddenCollabOnlyGuestFieldUpdate(makeCtx(user), tx, user)
+      expect(forbidden).toBe(false)
+    })
+  })
 })
diff --git a/foundations/server/packages/postgres/src/storage.ts b/foundations/server/packages/postgres/src/storage.ts
index c2fec296227..be24d59098d 100644
--- a/foundations/server/packages/postgres/src/storage.ts
+++ b/foundations/server/packages/postgres/src/storage.ts
@@ -210,6 +210,11 @@ class ValuesVariables {
 }
 
 abstract class PostgresAdapterBase implements DbAdapter {
+  // Postgres enforces collaborator-grant read security via addSecurity's collab
+  // OR-branch (see getSecurityClause below), so the space-security middleware may
+  // safely drop the space filter for collab-read bypasses on this backend.
+  readonly supportsCollaboratorSecurity = true
+
   protected readonly _helper: DBCollectionHelper
   protected readonly tableFields = new Map<string, string[]>()
 
@@ -647,6 +652,24 @@ abstract class PostgresAdapterBase implements DbAdapter {
             collabRes += ` OR EXISTS (SELECT 1 FROM ${translateDomain(DOMAIN_COLLABORATOR)} collab_sec WHERE collab_sec."workspaceId" = ${vars.add(this.workspaceId, '::uuid')} AND collab_sec."attachedTo" = ${domain}."attachedTo" AND collab_sec.collaborator = '${acc.uuid}')`
           }
         }
+        // Self-Collaborator visibility: any non-Admin/non-System caller can always read
+        // their own Collaborator records, regardless of space membership. Without this,
+        // a Guest who is a Collaborator on a doc in a project they are not a member of
+        // could never enumerate their own subscriptions (e.g. the tracker "Subscribed"
+        // tab queries Collaborator by `{collaborator: self}`).
+        if (domain === DOMAIN_COLLABORATOR) {
+          collabRes += ` OR ${domain}.collaborator = '${acc.uuid}'`
+        }
+        // Containing-Space visibility for collab-only Guests: surface Spaces that
+        // host docs the caller is a Collaborator on. Required for the project/space
+        // nav tree to list such projects (and for any code resolving the doc's
+        // parent space to succeed). The Collaborator record's `space` field always
+        // mirrors the parent doc's `space`, so existence of any such record naming
+        // the caller is sufficient evidence that the Space contains something they
+        // can see.
+        if (domain === DOMAIN_SPACE && [AccountRole.Guest, AccountRole.ReadOnlyGuest].includes(acc.role)) {
+          collabRes += ` OR EXISTS (SELECT 1 FROM ${translateDomain(DOMAIN_COLLABORATOR)} space_collab WHERE space_collab."workspaceId" = ${vars.add(this.workspaceId, '::uuid')} AND space_collab.space = ${domain}._id AND space_collab.collaborator = '${acc.uuid}')`
+        }
         return `AND (${res}${collabRes})`
       }
     }
diff --git a/models/core/src/core.ts b/models/core/src/core.ts
index d6f4588a905..310a17f3dce 100644
--- a/models/core/src/core.ts
+++ b/models/core/src/core.ts
@@ -438,6 +438,7 @@ export class TClassCollaborators extends TDoc implements ClassCollaborators<Doc>
   fields!: (keyof Doc)[]
   provideSecurity?: boolean
   provideAttachedSecurity?: boolean
+  mentionsGrantAccess?: boolean
 }
 
 @Model(core.class.Collaborator, core.class.Doc, DOMAIN_COLLABORATOR)
diff --git a/models/tracker/src/index.ts b/models/tracker/src/index.ts
index baabea1381a..1296c8c1f17 100644
--- a/models/tracker/src/index.ts
+++ b/models/tracker/src/index.ts
@@ -523,7 +523,17 @@ export function createModel (builder: Builder): void {
 
   builder.createDoc<ClassCollaborators<Issue>>(core.class.ClassCollaborators, core.space.Model, {
     attachedTo: tracker.class.Issue,
-    fields: ['createdBy', 'assignee']
+    fields: ['createdBy', 'assignee'],
+    // Collaborator status grants read visibility on the issue, bypassing
+    // project-space membership. Used so a user @-mentioned on an issue
+    // they are not a project member of can actually see and comment on it.
+    provideSecurity: true,
+    // @-mentions in chat/activity messages on an issue auto-create a
+    // Collaborator record (server-plugins/chunter-resources). Combined
+    // with provideSecurity above, the mentioned user gets explicit,
+    // disclosed read+comment access. Field writes remain blocked for
+    // collab-only guests by the GuestPermissions middleware veto.
+    mentionsGrantAccess: true
   })
 
   builder.mixin(tracker.class.Issue, core.class.Class, setting.mixin.Editable, {
diff --git a/plugins/chunter-resources/package.json b/plugins/chunter-resources/package.json
index 05123872f19..ff2c420eb37 100644
--- a/plugins/chunter-resources/package.json
+++ b/plugins/chunter-resources/package.json
@@ -57,6 +57,7 @@
     "@hcengineering/preference": "workspace:^0.7.0",
     "@hcengineering/presentation": "workspace:^0.7.0",
     "@hcengineering/text": "workspace:^0.7.19",
+    "@hcengineering/text-core": "workspace:^0.7.19",
     "@hcengineering/ui": "workspace:^0.7.0",
     "@hcengineering/view": "workspace:^0.7.0",
     "@hcengineering/view-resources": "workspace:^0.7.0",
diff --git a/plugins/chunter-resources/src/__tests__/mentionGrants.test.ts b/plugins/chunter-resources/src/__tests__/mentionGrants.test.ts
new file mode 100644
index 00000000000..bbf5f5eab9f
--- /dev/null
+++ b/plugins/chunter-resources/src/__tests__/mentionGrants.test.ts
@@ -0,0 +1,50 @@
+import { markupToJSON, jsonToMarkup, type MarkupNode, MarkupNodeType } from '@hcengineering/text-core'
+import { applyMentionGrantChoices } from '../mentionGrants'
+
+function refNode (id: string): MarkupNode {
+  return { type: MarkupNodeType.reference, attrs: { id, label: id, objectclass: 'contact:class:Person' } }
+}
+function docMarkup (...refs: MarkupNode[]): string {
+  return jsonToMarkup({ type: MarkupNodeType.doc, content: refs })
+}
+function grantsOf (markup: string, id: string): Array<'true' | 'false' | undefined> {
+  const node = markupToJSON(markup)
+  const out: Array<'true' | 'false' | undefined> = []
+  const walk = (n: MarkupNode): void => {
+    if (n.type === MarkupNodeType.reference && n.attrs?.id === id) {
+      out.push(n.attrs.grantsAccess as 'true' | 'false' | undefined)
+    }
+    n.content?.forEach(walk)
+  }
+  walk(node)
+  return out
+}
+
+describe('applyMentionGrantChoices', () => {
+  test('deselect sets grantsAccess=false on the person reference', () => {
+    const result = applyMentionGrantChoices(docMarkup(refNode('p1')), new Map([['p1', false]]))
+    expect(grantsOf(result, 'p1')).toEqual(['false'])
+  })
+
+  test('select sets grantsAccess=true explicitly', () => {
+    const result = applyMentionGrantChoices(docMarkup(refNode('p1')), new Map([['p1', true]]))
+    expect(grantsOf(result, 'p1')).toEqual(['true'])
+  })
+
+  test('deselect rewrites EVERY reference to that person', () => {
+    const result = applyMentionGrantChoices(docMarkup(refNode('p1'), refNode('p1')), new Map([['p1', false]]))
+    expect(grantsOf(result, 'p1')).toEqual(['false', 'false'])
+  })
+
+  test('persons absent from the choice map are left unchanged', () => {
+    const result = applyMentionGrantChoices(docMarkup(refNode('p1'), refNode('p2')), new Map([['p1', false]]))
+    expect(grantsOf(result, 'p1')).toEqual(['false'])
+    expect(grantsOf(result, 'p2')).toEqual([undefined])
+  })
+
+  test('empty choice map is a no-op', () => {
+    const markup = docMarkup(refNode('p1'))
+    const result = applyMentionGrantChoices(markup, new Map())
+    expect(grantsOf(result, 'p1')).toEqual([undefined])
+  })
+})
diff --git a/plugins/chunter-resources/src/components/chat-message/ChatMessageInput.svelte b/plugins/chunter-resources/src/components/chat-message/ChatMessageInput.svelte
index 4f9c51ed2c4..328ebf56d54 100644
--- a/plugins/chunter-resources/src/components/chat-message/ChatMessageInput.svelte
+++ b/plugins/chunter-resources/src/components/chat-message/ChatMessageInput.svelte
@@ -17,16 +17,30 @@
   import { Analytics } from '@hcengineering/analytics'
   import { AttachmentRefInput } from '@hcengineering/attachment-resources'
   import chunter, { ChatMessage, ChunterEvents, ThreadMessage } from '@hcengineering/chunter'
-  import { Class, Doc, generateId, getCurrentAccount, Ref, type CommitResult } from '@hcengineering/core'
+  import contact, { type Person } from '@hcengineering/contact'
+  import core, {
+    type AccountUuid,
+    Class,
+    Doc,
+    generateId,
+    getCurrentAccount,
+    Ref,
+    resolveMentionGrantTarget,
+    type Space,
+    type CommitResult
+  } from '@hcengineering/core'
   import { createQuery, DraftController, draftsStore, getClient } from '@hcengineering/presentation'
-  import { EmptyMarkup, isEmptyMarkup } from '@hcengineering/text'
+  import { EmptyMarkup, isEmptyMarkup, markupToJSON } from '@hcengineering/text'
+  import { extractReferences } from '@hcengineering/text-core'
   import { createEventDispatcher } from 'svelte'
   import { getObjectId } from '@hcengineering/view-resources'
-  import { ThrottledCaller } from '@hcengineering/ui'
+  import { showPopup, ThrottledCaller } from '@hcengineering/ui'
   import { getSpace, editingMessageStore } from '@hcengineering/activity-resources'
 
   import { getChannelSpace } from '../../utils'
+  import { applyMentionGrantChoices } from '../../mentionGrants'
   import ChannelTypingInfo from '../ChannelTypingInfo.svelte'
+  import MentionGrantConfirm from './MentionGrantConfirm.svelte'
 
   export let object: Doc
   export let chatMessage: ChatMessage | undefined = undefined
@@ -126,47 +140,123 @@
     currentMessage.attachments = attachments
   }
 
-  async function handleCreate (event: CustomEvent, _id: Ref<ChatMessage>): Promise<void> {
+  /**
+   * Disclosure UX for the mention-grants-access flow. Resolves the set of NEW
+   * grantees (mentioned Persons not already in the grant-target space) and asks
+   * the actor to confirm/deselect each. Returns:
+   *   - null  => cancel (do not send)
+   *   - Map   => send; map is personId -> grant choice (true/false). Empty map
+   *              when there is nothing to disclose (send unchanged).
+   * The actual access grant happens server-side via the chunter trigger; this
+   * dialog only discloses + lets the actor opt specific people out.
+   */
+  async function resolveMentionGrantChoices (markup: string): Promise<Map<string, boolean> | null> {
+    if (markup === undefined || markup === '' || isEmptyMarkup(markup)) return new Map()
+    let node
     try {
+      node = markupToJSON(markup)
+    } catch {
+      return new Map()
+    }
+    const references = extractReferences(node)
+    const mentionedPersonIds = references
+      .filter(({ objectClass }) => hierarchy.isDerived(objectClass, contact.class.Person))
+      .filter(({ grantsAccess }) => grantsAccess !== 'false') // V3c: already-denied refs need no disclosure
+      .map(({ objectId }) => objectId as Ref<Person>)
+    if (mentionedPersonIds.length === 0) return new Map()
+
+    const grantTarget = await resolveMentionGrantTarget(object, (cls, q, o) => client.findAll(cls, q, o))
+    if (grantTarget == null) return new Map()
+
+    const space = (await client.findAll<Space>(core.class.Space, { _id: grantTarget.space }))[0]
+    if (space === undefined) return new Map()
+    const members = new Set<AccountUuid>(space.members ?? [])
+
+    const persons = await client.findAll(contact.class.Person, { _id: { $in: mentionedPersonIds } })
+    const newGrantees = persons.filter((p) => p.personUuid != null && !members.has(p.personUuid as AccountUuid))
+    if (newGrantees.length === 0) return new Map()
+
+    const targetName: string = (grantTarget as any).name ?? (grantTarget as any).title ?? grantTarget._id
+    const spaceName: string = (space as any).name ?? space._id
+    const grantees = newGrantees.map((p) => ({ id: p._id, name: p.name ?? String(p.personUuid) }))
+
+    return await new Promise<Map<string, boolean> | null>((resolve) => {
+      showPopup(MentionGrantConfirm, { grantees, targetName, spaceName }, undefined, (res?: Map<string, boolean>) => {
+        resolve(res instanceof Map ? res : null)
+      })
+    })
+  }
+
+  // Runs the mention-grants disclosure for an outgoing/edited message and
+  // rewrites event.detail.message with the actor's per-grantee choices.
+  // Returns false if the actor cancelled (caller must abort the send).
+  async function prepareMentionGrantChoices (event: CustomEvent): Promise<boolean> {
+    const markup = event.detail?.message
+    const choices = await resolveMentionGrantChoices(typeof markup === 'string' ? markup : '')
+    if (choices === null) return false // actor cancelled
+    if (choices.size > 0 && typeof markup === 'string') {
+      event.detail.message = applyMentionGrantChoices(markup, choices)
+    }
+    return true
+  }
+
+  // Returns true if the message was sent, false if the actor cancelled the
+  // grant dialog or the send failed. The caller (onMessage) must only clear
+  // the draft/input on a true result, otherwise a cancelled grant dialog
+  // would lose the unsent comment.
+  async function handleCreate (event: CustomEvent, _id: Ref<ChatMessage>): Promise<boolean> {
+    try {
+      if (!(await prepareMentionGrantChoices(event))) return false
+
       const res = await createMessage(event, _id, `chunter.create.${_class} ${object._class}`)
 
       console.log(`create.${_class} measure`, res.serverTime, res.time)
       const objectId = await getObjectId(object, client.getHierarchy())
       Analytics.handleEvent(ChunterEvents.MessageCreated, { ok: res.result, objectId, objectClass: object._class })
+      return true
     } catch (err: any) {
       const objectId = await getObjectId(object, client.getHierarchy())
       Analytics.handleEvent(ChunterEvents.MessageCreated, { ok: false, objectId, objectClass: object._class })
       Analytics.handleError(err)
+      return false
     }
   }
 
-  async function handleEdit (event: CustomEvent): Promise<void> {
+  async function handleEdit (event: CustomEvent): Promise<boolean> {
     try {
+      if (!(await prepareMentionGrantChoices(event))) return false
+
       await editMessage(event)
       const objectId = await getObjectId(object, client.getHierarchy())
       Analytics.handleEvent(ChunterEvents.MessageEdited, { ok: true, objectId, objectClass: object._class })
+      return true
     } catch (err: any) {
       const objectId = await getObjectId(object, client.getHierarchy())
       Analytics.handleEvent(ChunterEvents.MessageEdited, { ok: false, objectId, objectClass: object._class })
       Analytics.handleError(err)
+      return false
     }
   }
 
   async function onMessage (event: CustomEvent): Promise<void> {
-    draftController.remove()
-    inputRef.removeDraft(false)
+    loading = true
 
+    let ok = false
     if (chatMessage !== undefined) {
-      loading = true
-      await handleEdit(event)
+      ok = await handleEdit(event)
     } else {
-      void handleCreate(event, _id)
+      ok = await handleCreate(event, _id)
       void deleteTypingInfo()
     }
 
-    // Remove draft from Local Storage
-    clear()
-    dispatch('submit', false)
+    // Only clear the input / drop the draft after a successful send or edit.
+    // A cancelled grant dialog (ok === false) must preserve the unsent comment.
+    if (ok) {
+      draftController.remove()
+      inputRef.removeDraft(false)
+      clear()
+      dispatch('submit', false)
+    }
     loading = false
   }
 
diff --git a/plugins/chunter-resources/src/components/chat-message/MentionGrantConfirm.svelte b/plugins/chunter-resources/src/components/chat-message/MentionGrantConfirm.svelte
new file mode 100644
index 00000000000..fa5e29a8fd1
--- /dev/null
+++ b/plugins/chunter-resources/src/components/chat-message/MentionGrantConfirm.svelte
@@ -0,0 +1,68 @@
+<!--
+// Copyright © 2026 Hardcore Engineering Inc.
+//
+// Licensed under the Eclipse Public License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License. You may
+// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
+-->
+<script lang="ts">
+  import { createEventDispatcher } from 'svelte'
+  import { Button, CheckBox, Label } from '@hcengineering/ui'
+  import { getEmbeddedLabel } from '@hcengineering/platform'
+
+  // One entry per NEW grantee (people not already members of the grant-target space).
+  export let grantees: Array<{ id: string, name: string }>
+  export let targetName: string
+  export let spaceName: string
+
+  const dispatch = createEventDispatcher()
+
+  // Default: grant everyone (preserves pre-V3 behaviour). A plain array with
+  // per-row `granted` so `bind:checked` stays reactive (mutating a Map would
+  // not re-render the CheckBox in Svelte 4).
+  const rows = grantees.map((g) => ({ id: g.id, name: g.name, granted: true }))
+
+  function onCancel (): void {
+    dispatch('close', undefined) // undefined => caller treats as cancel
+  }
+
+  function onSend (): void {
+    // Emit the full choice map so the caller can rewrite the markup.
+    dispatch('close', new Map(rows.map((r) => [r.id, r.granted])))
+  }
+</script>
+
+<div class="msgbox-container">
+  <div class="overflow-label fs-title mb-4">
+    <Label label={getEmbeddedLabel('This mention grants access')} />
+  </div>
+  <div class="mb-4">
+    <Label
+      label={getEmbeddedLabel(
+        `Selected people will get read access to "${targetName}" in "${spaceName}" and the ability to comment. They cannot edit the document's fields. Uncheck anyone you do not want to grant access to.`
+      )}
+    />
+  </div>
+  {#each rows as row (row.id)}
+    <div class="flex-row-center mb-2">
+      <CheckBox bind:checked={row.granted} kind="primary" />
+      <span class="ml-2 overflow-label">{row.name}</span>
+    </div>
+  {/each}
+  <div class="flex-row-reverse mt-4">
+    <Button label={getEmbeddedLabel('Send with selected grants')} kind="primary" on:click={onSend} />
+    <div class="mr-2">
+      <Button label={getEmbeddedLabel('Cancel')} on:click={onCancel} />
+    </div>
+  </div>
+</div>
+
+<style lang="scss">
+  .msgbox-container {
+    display: flex;
+    flex-direction: column;
+    padding: 1rem;
+    min-width: 20rem;
+    max-width: 30rem;
+  }
+</style>
diff --git a/plugins/chunter-resources/src/mentionGrants.ts b/plugins/chunter-resources/src/mentionGrants.ts
new file mode 100644
index 00000000000..e8056e3661c
--- /dev/null
+++ b/plugins/chunter-resources/src/mentionGrants.ts
@@ -0,0 +1,50 @@
+//
+// Copyright © 2026 Hardcore Engineering Inc.
+//
+// Licensed under the Eclipse Public License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License. You may
+// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
+//
+
+import { markupToJSON, jsonToMarkup, type MarkupNode, MarkupNodeType } from '@hcengineering/text-core'
+import { type Markup } from '@hcengineering/core'
+
+/**
+ * Rewrite the grantsAccess attribute on mention references in a message's
+ * markup according to per-person choices made in the send-time disclosure.
+ *
+ * - choice === false  -> set grantsAccess='false' on EVERY reference to that
+ *   person. Setting all of them is required because extractReferences merges
+ *   any-wins: a single remaining undefined reference would re-grant access.
+ * - choice === true   -> set grantsAccess='true' explicitly.
+ * - person not in the map -> left unchanged (e.g. existing space members,
+ *   whose mentions stay undefined and grant-by-default as before).
+ *
+ * Pure function: returns a new markup string; does not mutate its input
+ * string (it parses, mutates the parsed tree, and re-serializes).
+ */
+export function applyMentionGrantChoices (markup: Markup, choices: Map<string, boolean>): Markup {
+  if (choices.size === 0) return markup
+  let node: MarkupNode
+  try {
+    node = markupToJSON(markup)
+  } catch {
+    return markup
+  }
+
+  const walk = (n: MarkupNode): void => {
+    // Use `!= null` to guard against both `undefined` AND `null` — a defensive
+    // attrs == null on a reference node would otherwise throw on n.attrs.id.
+    if (n.type === MarkupNodeType.reference && n.attrs != null) {
+      const id = n.attrs.id as string
+      const choice = choices.get(id)
+      if (choice !== undefined) {
+        n.attrs.grantsAccess = choice ? 'true' : 'false'
+      }
+    }
+    n.content?.forEach(walk)
+  }
+  walk(node)
+
+  return jsonToMarkup(node)
+}
diff --git a/plugins/tracker-assets/lang/de.json b/plugins/tracker-assets/lang/de.json
index d1e698c9c9a..130d8a89ee3 100644
--- a/plugins/tracker-assets/lang/de.json
+++ b/plugins/tracker-assets/lang/de.json
@@ -293,7 +293,8 @@
     "UnsetParentIssue": "Übergeordnete Aufgabe entfernen",
     "ForbidCreateProjectPermission": "Projekterstellung verbieten",
     "ForbidCreateProjectPermissionDescription": "Verbietet Benutzern das Erstellen neuer Projekte",
-    "AllowCreatingIssues": "Erstellen von Aufgaben erlauben"
+    "AllowCreatingIssues": "Erstellen von Aufgaben erlauben",
+    "SharedWithYouTooltip": "Du hast nur Zugriff auf einzelne Issues; du bist kein Mitglied dieses Projekts"
   },
   "status": {}
 }
diff --git a/plugins/tracker-assets/lang/en.json b/plugins/tracker-assets/lang/en.json
index 3d856a20031..a4b92987f92 100644
--- a/plugins/tracker-assets/lang/en.json
+++ b/plugins/tracker-assets/lang/en.json
@@ -293,7 +293,8 @@
     "UnsetParentIssue": "Unset parent issue",
     "ForbidCreateProjectPermission": "Forbid create project",
     "ForbidCreateProjectPermissionDescription": "Forbid users creating new projects",
-    "AllowCreatingIssues": "Allow creating issues"
+    "AllowCreatingIssues": "Allow creating issues",
+    "SharedWithYouTooltip": "You have access to specific issues only; you are not a member of this project"
   },
   "status": {}
 }
diff --git a/plugins/tracker-assets/lang/ru.json b/plugins/tracker-assets/lang/ru.json
index 7ccd4cb5ccd..7761662a737 100644
--- a/plugins/tracker-assets/lang/ru.json
+++ b/plugins/tracker-assets/lang/ru.json
@@ -293,7 +293,8 @@
     "UnsetParentIssue": "Снять родительскую задачу",
     "ForbidCreateProjectPermission": "Запретить создание проекта",
     "ForbidCreateProjectPermissionDescription": "Запрещает пользователям создавать новые проекты",
-    "AllowCreatingIssues": "Разрешить создание задач"
+    "AllowCreatingIssues": "Разрешить создание задач",
+    "SharedWithYouTooltip": "У вас есть доступ только к отдельным задачам; вы не являетесь участником этого проекта"
   },
   "status": {}
 }
diff --git a/plugins/tracker-resources/src/components/issues/edit/EditIssue.svelte b/plugins/tracker-resources/src/components/issues/edit/EditIssue.svelte
index bf7de0a5db4..2633a1d21ec 100644
--- a/plugins/tracker-resources/src/components/issues/edit/EditIssue.svelte
+++ b/plugins/tracker-resources/src/components/issues/edit/EditIssue.svelte
@@ -47,7 +47,7 @@
 
   import { createEventDispatcher, onDestroy } from 'svelte'
   import { generateIssueShortLink, getIssueIdByIdentifier } from '../../../issues'
-  import { canEditIssue } from '../../../utils'
+  import { canCommentOnIssue, canEditIssueFields } from '../../../utils'
   import tracker from '../../../plugin'
   import IssueStatusActivity from '../IssueStatusActivity.svelte'
   import ControlPanel from './ControlPanel.svelte'
@@ -73,16 +73,29 @@
   let descriptionBox: AttachmentStyleBoxCollabEditor
   let showAllMixins: boolean
 
+  // Two independent gates:
+  //   effectiveReadonly — Issue field editors (title, status, dates, ...).
+  //                       Driven by canEditIssueFields(). Guests are blocked.
+  //   canComment        — Comment composer at the bottom of the panel.
+  //                       Driven by canCommentOnIssue(). Guests who are
+  //                       Creator OR Collaborator on the issue are allowed.
   let effectiveReadonly = true
+  let canComment = false
   $: if (issue !== undefined) {
     const currentIssue = issue
-    void canEditIssue(currentIssue).then((canEdit) => {
+    void canEditIssueFields(currentIssue).then((canEdit) => {
       if (issue === currentIssue) {
         effectiveReadonly = readonly || !canEdit
       }
     })
+    void canCommentOnIssue(currentIssue).then((v) => {
+      if (issue === currentIssue) {
+        canComment = !readonly && v
+      }
+    })
   } else {
     effectiveReadonly = readonly
+    canComment = false
   }
 
   const inboxClient = InboxNotificationsClientImpl.getClient()
@@ -211,7 +224,7 @@
   <Panel
     object={issue}
     isHeader={false}
-    withoutInput={effectiveReadonly}
+    withoutInput={!canComment}
     allowClose={!embedded}
     isAside={true}
     isSub={false}
diff --git a/plugins/tracker-resources/src/components/projects/ProjectSpacePresenter.svelte b/plugins/tracker-resources/src/components/projects/ProjectSpacePresenter.svelte
index 17f004068b6..a7d2b271a9b 100644
--- a/plugins/tracker-resources/src/components/projects/ProjectSpacePresenter.svelte
+++ b/plugins/tracker-resources/src/components/projects/ProjectSpacePresenter.svelte
@@ -13,12 +13,13 @@
 // limitations under the License.
 -->
 <script lang="ts">
-  import { Ref, Space } from '@hcengineering/core'
+  import { getCurrentAccount, Ref, Space } from '@hcengineering/core'
   import { getResource } from '@hcengineering/platform'
   import { Project } from '@hcengineering/tracker'
   import { IconWithEmoji } from '@hcengineering/presentation'
-  import { getPlatformColorDef, getPlatformColorForTextDef, themeStore, type Action } from '@hcengineering/ui'
+  import { getPlatformColorDef, getPlatformColorForTextDef, themeStore, tooltip, type Action } from '@hcengineering/ui'
   import view from '@hcengineering/view'
+  import tracker from '../../plugin'
   import { NavLink, TreeNode } from '@hcengineering/view-resources'
   import { SpacesNavModel, SpecialNavModel } from '@hcengineering/workbench'
   import { SpecialElement } from '@hcengineering/workbench-resources'
@@ -33,7 +34,20 @@
 
   let specials: SpecialNavModel[] = []
 
-  async function updateSpecials (model: SpacesNavModel, space: Project): Promise<void> {
+  // Hide non-Issues specials (Components / Milestones / Templates) on
+  // collab-only projects — the user has read on individual issues via
+  // Collaborator records but no membership in the project itself, so
+  // those sub-views would be empty and confusing. The Issues sub-view
+  // stays because the postgres adapter's collab-OR-branch surfaces the
+  // doc-level visibility there.
+  // V1: guard against space.members being null/undefined — Huly's sample
+  // projects + auto-templated projects can ship without an explicit members
+  // array (the DB stores NULL). Without the ?? [], `null.includes(...)` throws
+  // and isCollabOnlyProject silently becomes undefined → the filter never
+  // fires and the badge + sub-node hide silently break.
+  $: isCollabOnlyProject = !(space.members ?? []).includes(getCurrentAccount().uuid)
+
+  async function updateSpecials (model: SpacesNavModel, space: Project, collabOnly: boolean): Promise<void> {
     const newSpecials: SpecialNavModel[] = []
     for (const sp of model.specials ?? []) {
       let shouldAdd = true
@@ -43,6 +57,19 @@
           shouldAdd = await visibleIf([space])
         }
       }
+      // Filter to Issues only when the caller is not a member; everything
+      // else (Components / Milestones / Templates) would render as an
+      // empty list and clutter the tree.
+      // SCOPE LIMIT (V1): only `tracker.class.Issue` opts into mentions-
+      // grant-access today (see models/tracker/src/index.ts). If another
+      // tracker class later sets ClassCollaborators.provideSecurity = true
+      // + grants its own Collaborator edges, this hard-coded `'issues'`
+      // check will hide that class's sub-view for collab-only Guests.
+      // Make the check class- or special-driven before flipping the
+      // second opt-in.
+      if (shouldAdd && collabOnly && sp.id !== 'issues') {
+        shouldAdd = false
+      }
       if (shouldAdd) {
         newSpecials.push(sp)
       }
@@ -50,8 +77,11 @@
     specials = newSpecials
   }
 
+  // V1: re-derive specials whenever isCollabOnlyProject flips too — otherwise
+  // the user being added to / removed from the project mid-session keeps the
+  // sub-views (Components / Milestones / Templates) stale until a reload.
   $: if (model != null) {
-    void updateSpecials(model, space)
+    void updateSpecials(model, space, isCollabOnlyProject)
   }
   $: visible =
     (!deselect && currentSpace !== undefined && currentSpecial !== undefined && space._id === currentSpace) ||
@@ -59,44 +89,90 @@
 </script>
 
 {#if specials}
-  <TreeNode
-    _id={space?._id}
-    icon={space?.icon === view.ids.IconWithEmoji ? IconWithEmoji : (space?.icon ?? model?.icon)}
-    iconProps={space?.icon === view.ids.IconWithEmoji
-      ? { icon: space.color }
-      : {
-          fill:
-            space.color !== undefined && typeof space.color !== 'string'
-              ? getPlatformColorDef(space.color, $themeStore.dark).icon
-              : getPlatformColorForTextDef(space.name, $themeStore.dark).icon
-        }}
-    title={space.name}
-    type={'nested'}
-    highlighted={space._id === currentSpace}
-    {visible}
-    actions={() => getActions(space)}
-    {forciblyСollapsed}
-  >
-    {#each specials as special}
-      <NavLink space={space._id} special={special.id}>
-        <SpecialElement
-          indent
-          label={special.label}
-          icon={special.icon}
-          selected={deselect ? false : currentSpace === space._id && special.id === currentSpecial}
-        />
-      </NavLink>
-    {/each}
-
-    <svelte:fragment slot="visible">
-      {#if visible}
-        {@const item = specials.find((sp) => sp.id === currentSpecial && currentSpace === space._id)}
-        {#if item}
-          <NavLink space={space._id} special={item.id}>
-            <SpecialElement indent label={item.label} icon={item.icon} selected forciblyСollapsed />
+  {#if isCollabOnlyProject}
+    <div use:tooltip={{ label: tracker.string.SharedWithYouTooltip }}>
+      <TreeNode
+        _id={space?._id}
+        icon={space?.icon === view.ids.IconWithEmoji ? IconWithEmoji : (space?.icon ?? model?.icon)}
+        iconProps={space?.icon === view.ids.IconWithEmoji
+          ? { icon: space.color, opacity: 0.6 }
+          : {
+              fill:
+                space.color !== undefined && typeof space.color !== 'string'
+                  ? getPlatformColorDef(space.color, $themeStore.dark).icon
+                  : getPlatformColorForTextDef(space.name, $themeStore.dark).icon,
+              opacity: 0.6
+            }}
+        title={space.name}
+        type={'nested'}
+        highlighted={space._id === currentSpace}
+        {visible}
+        actions={() => getActions(space)}
+        {forciblyСollapsed}
+      >
+        {#each specials as special}
+          <NavLink space={space._id} special={special.id}>
+            <SpecialElement
+              indent
+              label={special.label}
+              icon={special.icon}
+              selected={deselect ? false : currentSpace === space._id && special.id === currentSpecial}
+            />
           </NavLink>
+        {/each}
+
+        <svelte:fragment slot="visible">
+          {#if visible}
+            {@const item = specials.find((sp) => sp.id === currentSpecial && currentSpace === space._id)}
+            {#if item}
+              <NavLink space={space._id} special={item.id}>
+                <SpecialElement indent label={item.label} icon={item.icon} selected forciblyСollapsed />
+              </NavLink>
+            {/if}
+          {/if}
+        </svelte:fragment>
+      </TreeNode>
+    </div>
+  {:else}
+    <TreeNode
+      _id={space?._id}
+      icon={space?.icon === view.ids.IconWithEmoji ? IconWithEmoji : (space?.icon ?? model?.icon)}
+      iconProps={space?.icon === view.ids.IconWithEmoji
+        ? { icon: space.color }
+        : {
+            fill:
+              space.color !== undefined && typeof space.color !== 'string'
+                ? getPlatformColorDef(space.color, $themeStore.dark).icon
+                : getPlatformColorForTextDef(space.name, $themeStore.dark).icon
+          }}
+      title={space.name}
+      type={'nested'}
+      highlighted={space._id === currentSpace}
+      {visible}
+      actions={() => getActions(space)}
+      {forciblyСollapsed}
+    >
+      {#each specials as special}
+        <NavLink space={space._id} special={special.id}>
+          <SpecialElement
+            indent
+            label={special.label}
+            icon={special.icon}
+            selected={deselect ? false : currentSpace === space._id && special.id === currentSpecial}
+          />
+        </NavLink>
+      {/each}
+
+      <svelte:fragment slot="visible">
+        {#if visible}
+          {@const item = specials.find((sp) => sp.id === currentSpecial && currentSpace === space._id)}
+          {#if item}
+            <NavLink space={space._id} special={item.id}>
+              <SpecialElement indent label={item.label} icon={item.icon} selected forciblyСollapsed />
+            </NavLink>
+          {/if}
         {/if}
-      {/if}
-    </svelte:fragment>
-  </TreeNode>
+      </svelte:fragment>
+    </TreeNode>
+  {/if}
 {/if}
diff --git a/plugins/tracker-resources/src/index.ts b/plugins/tracker-resources/src/index.ts
index 071a13ac73f..0f0a7cf1b72 100644
--- a/plugins/tracker-resources/src/index.ts
+++ b/plugins/tracker-resources/src/index.ts
@@ -14,7 +14,7 @@
 //
 
 import { Analytics } from '@hcengineering/analytics'
-import {
+import core, {
   type Attribute,
   type Class,
   type Client,
@@ -517,7 +517,19 @@ export default async (): Promise<Resources> => ({
     ) => await getAllStates(query, onUpdate, queryId, attr, false),
     GetVisibleFilters: getVisibleFilters,
     IssueChatTitleProvider: getIssueChatTitle,
-    IsProjectJoined: async (project: Project) => project.members.includes(getCurrentAccount().uuid),
+    IsProjectJoined: async (project: Project) => {
+      const accountUuid = getCurrentAccount().uuid
+      if (project.members.includes(accountUuid)) return true
+      // Collab-only access: surface projects in the nav tree when the user is a
+      // Collaborator on any doc inside this project, even without space-membership.
+      // Backend security (postgres collabRes OR-branch + middleware bypass) limits
+      // what the user can actually open within the project.
+      const collab = await getClient().findOne(core.class.Collaborator, {
+        collaborator: accountUuid,
+        space: project._id
+      })
+      return collab !== undefined
+    },
     GetIssueStatusCategories: getIssueStatusCategories,
     SetComponentStore: setStore,
     ComponentFilterFunction: filterComponents,
diff --git a/plugins/tracker-resources/src/plugin.ts b/plugins/tracker-resources/src/plugin.ts
index eed088c59d5..dadcd1249b6 100644
--- a/plugins/tracker-resources/src/plugin.ts
+++ b/plugins/tracker-resources/src/plugin.ts
@@ -307,7 +307,8 @@ export default mergeIds(trackerId, tracker, {
     UnsetParent: '' as IntlString,
     PreviousAssigned: '' as IntlString,
     EditRelatedTargets: '' as IntlString,
-    RelatedIssueTargetDescription: '' as IntlString
+    RelatedIssueTargetDescription: '' as IntlString,
+    SharedWithYouTooltip: '' as IntlString
   },
   component: {
     NopeComponent: '' as AnyComponent,
diff --git a/plugins/tracker-resources/src/utils.ts b/plugins/tracker-resources/src/utils.ts
index c0afa1ed7bc..ef149701f6e 100644
--- a/plugins/tracker-resources/src/utils.ts
+++ b/plugins/tracker-resources/src/utils.ts
@@ -277,8 +277,21 @@ export async function moveIssuesToAnotherMilestone (
   }
 }
 
-export async function canEditIssue (issue?: Issue | WithLookup<Issue>): Promise<boolean> {
-  const client = getClient()
+/**
+ * True when the current user may edit Issue fields (title, description,
+ * status, dates, labels, assignee, dependencies, etc).
+ *
+ * Guest-tier accounts are blocked unconditionally — even when listed as
+ * Collaborator on the issue. Their Collaborator status grants read +
+ * comment via {@link canCommentOnIssue}, but not field-edit. This matches
+ * the server-side veto in the GuestPermissions middleware so the UI
+ * doesnt show editors that would fail on submit.
+ *
+ * Project-member guests (e.g. a guest who is a member of their own
+ * project) are also blocked here; if you need to allow them to
+ * edit issues they own, promote them to AccountRole.User+.
+ */
+export async function canEditIssueFields (issue?: Issue | WithLookup<Issue>): Promise<boolean> {
   if (issue === undefined) return false
 
   const account = getCurrentAccount()
@@ -286,14 +299,33 @@ export async function canEditIssue (issue?: Issue | WithLookup<Issue>): Promise<
     account.role === AccountRole.Guest ||
     account.role === AccountRole.DocGuest ||
     account.role === AccountRole.ReadOnlyGuest
+  return !isGuest
+}
+
+/**
+ * True when the current user may post comments on the Issue.
+ *
+ * - User+ accounts always pass.
+ * - ReadOnlyGuest is always blocked.
+ * - Other guests pass if they are the Issues creator OR they are listed
+ *   as Collaborator on the issue (auto-added via @-mention by the
+ *   chunter trigger when mentionsGrantAccess is set on the class, or
+ *   added manually via the Collaborators editor in the panel).
+ */
+export async function canCommentOnIssue (issue?: Issue | WithLookup<Issue>): Promise<boolean> {
+  if (issue === undefined) return false
 
+  const account = getCurrentAccount()
+  if (account.role === AccountRole.ReadOnlyGuest) return false
+
+  const isGuest = account.role === AccountRole.Guest || account.role === AccountRole.DocGuest
   if (!isGuest) return true
 
   const isCreator =
     issue.createdBy !== undefined && Array.isArray(account.socialIds) && account.socialIds.includes(issue.createdBy)
-
   if (isCreator) return true
 
+  const client = getClient()
   const collaborator = await client.findOne(core.class.Collaborator, {
     attachedTo: issue._id,
     collaborator: account.uuid
@@ -301,6 +333,13 @@ export async function canEditIssue (issue?: Issue | WithLookup<Issue>): Promise<
   return collaborator !== undefined
 }
 
+/**
+ * Backwards-compat alias for callers that have not yet migrated to
+ * {@link canEditIssueFields}. New code should use the explicit split.
+ * Tag for removal in a follow-up sweep across tracker-resources.
+ */
+export const canEditIssue = canEditIssueFields
+
 export function getTimeReportDate (type: TimeReportDayType): number {
   const date = new Date(Date.now())
 
diff --git a/plugins/workbench-resources/src/components/Navigator.svelte b/plugins/workbench-resources/src/components/Navigator.svelte
index ca09ae04e37..21aab9d8cc2 100644
--- a/plugins/workbench-resources/src/components/Navigator.svelte
+++ b/plugins/workbench-resources/src/components/Navigator.svelte
@@ -13,7 +13,7 @@
 // limitations under the License.
 -->
 <script lang="ts">
-  import core, { Doc, Ref, SortingOrder, Space, getCurrentAccount, hasAccountRole } from '@hcengineering/core'
+  import core, { Class, Doc, Ref, SortingOrder, Space, getCurrentAccount, hasAccountRole } from '@hcengineering/core'
   import { getResource } from '@hcengineering/platform'
   import preference, { SpacePreference } from '@hcengineering/preference'
   import { createQuery, getClient, isAdminUser } from '@hcengineering/presentation'
@@ -35,34 +35,92 @@
   const client = getClient()
   const hierarchy = client.getHierarchy()
   const query = createQuery()
+  // Collab-spaces: spaces that host docs the current account is a Collaborator on,
+  // even when the account is not in the space's `members`. Powers nav-tree visibility
+  // for collab-only Guests on classes that opted into ClassCollaborators.provideSecurity.
+  const collabSpaceLookupQuery = createQuery()
+  const collabSpaceQuery = createQuery()
 
-  let spaces: Space[] = []
+  let memberSpaces: Space[] = []
+  let collabSpaces: Space[] = []
+  let collabSpaceIds: Set<Ref<Space>> = new Set<Ref<Space>>()
   let starred: Space[] = []
   let shownSpaces: Space[] = []
 
   const adminUser = isAdminUser()
 
-  $: if (model) {
-    const classes = Array.from(new Set(getSpecialSpaceClass(model).flatMap((c) => hierarchy.getDescendants(c)))).filter(
-      (it) => !hierarchy.isMixin(it)
-    )
-    if (classes.length > 0) {
-      query.query<Space>(
-        classes.length === 1 ? classes[0] : core.class.Space,
-        !adminUser
-          ? {
-              ...(classes.length === 1 ? {} : { _class: { $in: classes } }),
-              members: getCurrentAccount().uuid
-            }
-          : { ...(classes.length === 1 ? {} : { _class: { $in: classes } }) },
-        (result) => {
-          spaces = result
-        },
-        { sort: { name: SortingOrder.Ascending } }
+  $: activeClasses = (
+    model
+      ? Array.from(new Set(getSpecialSpaceClass(model).flatMap((c) => hierarchy.getDescendants(c)))).filter(
+        (it) => !hierarchy.isMixin(it)
       )
-    } else {
-      query.unsubscribe()
-    }
+      : []
+  ) as Ref<Class<Space>>[]
+
+  $: spaces =
+    adminUser || collabSpaces.length === 0
+      ? memberSpaces
+      : (() => {
+          const seen = new Set(memberSpaces.map((s) => s._id))
+          return [...memberSpaces, ...collabSpaces.filter((s) => !seen.has(s._id))]
+        })()
+
+  $: if (model && activeClasses.length > 0) {
+    const classes = activeClasses
+    query.query<Space>(
+      classes.length === 1 ? classes[0] : core.class.Space,
+      !adminUser
+        ? {
+            ...(classes.length === 1 ? {} : { _class: { $in: classes } }),
+            members: getCurrentAccount().uuid
+          }
+        : { ...(classes.length === 1 ? {} : { _class: { $in: classes } }) },
+      (result) => {
+        memberSpaces = result
+      },
+      { sort: { name: SortingOrder.Ascending } }
+    )
+  } else if (model) {
+    query.unsubscribe()
+    memberSpaces = []
+  }
+
+  // Track every Space that hosts a Collaborator record naming the current account.
+  // We track unconditionally (cheap query, scoped to self by A6) and let the second
+  // query narrow by the navigator's class set.
+  $: if (!adminUser) {
+    collabSpaceLookupQuery.query(
+      core.class.Collaborator,
+      { collaborator: getCurrentAccount().uuid },
+      (collabs) => {
+        const next = new Set<Ref<Space>>(collabs.map((c) => c.space))
+        if (next.size !== collabSpaceIds.size || !Array.from(next).every((id) => collabSpaceIds.has(id))) {
+          collabSpaceIds = next
+        }
+      },
+      { projection: { space: 1 } }
+    )
+  } else {
+    collabSpaceLookupQuery.unsubscribe()
+    collabSpaceIds = new Set<Ref<Space>>()
+  }
+
+  $: if (!adminUser && collabSpaceIds.size > 0 && activeClasses.length > 0) {
+    const classes = activeClasses
+    collabSpaceQuery.query<Space>(
+      classes.length === 1 ? classes[0] : core.class.Space,
+      {
+        _id: { $in: Array.from(collabSpaceIds) },
+        ...(classes.length === 1 ? {} : { _class: { $in: classes } })
+      },
+      (result) => {
+        collabSpaces = result
+      },
+      { sort: { name: SortingOrder.Ascending } }
+    )
+  } else {
+    collabSpaceQuery.unsubscribe()
+    collabSpaces = []
   }
 
   let specials: SpecialNavModel[] = []
diff --git a/server-plugins/chunter-resources/src/__tests__/mentionGrantsTrigger.test.ts b/server-plugins/chunter-resources/src/__tests__/mentionGrantsTrigger.test.ts
new file mode 100644
index 00000000000..14d1fe66bb8
--- /dev/null
+++ b/server-plugins/chunter-resources/src/__tests__/mentionGrantsTrigger.test.ts
@@ -0,0 +1,345 @@
+import { type Tx, type TxCreateDoc } from '@hcengineering/core'
+import { jsonToMarkup, MarkupNodeType } from '@hcengineering/text-core'
+
+// Imported AFTER the mocks (jest.mock above is hoisted by ts-jest, so even
+// these top-level ESM imports see the mocked module). Avoid `require()` so
+// the file passes `tsc --noEmit` (the package's tsconfig only ships @types/jest).
+import { ChunterTrigger } from '../index'
+import coreDefault, { resolveMentionGrantTarget } from '@hcengineering/core'
+import { getDocCollaborators } from '@hcengineering/server-notification-resources'
+
+// ------------------------------------------------------------------
+// jest.mock for @hcengineering/core
+//
+// jest.requireActual('@hcengineering/core') crashes in ts-jest via spread
+// due to a circular-dependency in the compiled lib (import_component2
+// undefined during getter evaluation when all properties are accessed
+// eagerly). We work around this by requiring the actual module and only
+// accessing specific known-safe properties instead of spreading.
+// ------------------------------------------------------------------
+jest.mock('@hcengineering/core', () => {
+  // Load the real module but access only the specific properties we need.
+  // DO NOT spread with {...actual}: that triggers all lazy getters eagerly,
+  // hitting the circular-dep crash in import_component2.
+  const actual = jest.requireActual('@hcengineering/core')
+
+  // Build a proxy that delegates unknown property reads to the actual module.
+  // This avoids the eager spread while still giving server-core etc. access
+  // to toFindResult, TxProcessor, etc.
+  const proxy = new Proxy(actual, {
+    get (target: any, prop: string) {
+      if (prop === 'getClassCollaborators') return mockGetClassCollaborators
+      if (prop === 'resolveMentionGrantTarget') return mockResolveMentionGrantTarget
+      return target[prop]
+    }
+  })
+
+  const mockGetClassCollaborators = jest.fn(() => ({ provideSecurity: true, mentionsGrantAccess: true }))
+  const mockResolveMentionGrantTarget = jest.fn(async (doc: any) => doc)
+
+  return proxy
+})
+
+jest.mock('@hcengineering/server-contact', () => ({
+  getAccountBySocialId: jest.fn(async () => 'author-acc'),
+  getPerson: jest.fn(async () => undefined)
+}))
+
+// ------------------------------------------------------------------
+// jest.mock for @hcengineering/server-notification-resources (F3 infra).
+//
+// Needed by the in-flight-dedup tests (B/C) which drive the seed path
+// (currentCollaborators empty). getAddCollaboratTxes is implemented to
+// attach Collaborator records to TARGET._id ('issue-1') — this SIMULATES a
+// future world where the seed lands on the Issue itself (today it attaches
+// to the message via tx.objectId). The real class ids are pulled from the
+// actual core module so the emitted txes match coreDefault.class.* used by
+// the assertions. Existing tests never hit the seed branch (their
+// Collaborator findAll is non-empty), so these mocks are inert for them.
+// ------------------------------------------------------------------
+jest.mock('@hcengineering/server-notification-resources', () => {
+  const actualCore = jest.requireActual('@hcengineering/core')
+  const txCreateDocId = actualCore.default.class.TxCreateDoc
+  const collaboratorId = actualCore.default.class.Collaborator
+  return {
+    getDocCollaborators: jest.fn(async () => [] as string[]),
+    createCollaboratorNotifications: jest.fn(async () => []),
+    getAddCollaboratTxes: jest.fn(
+      (_objectId: any, _objectClass: any, _objectSpace: any, _control: any, collaborators: string[]) =>
+        collaborators.map((c) => ({
+          _class: txCreateDocId,
+          objectClass: collaboratorId,
+          objectSpace: 'space-1',
+          attributes: {
+            attachedTo: 'issue-1',
+            attachedToClass: 'tracker:class:Issue',
+            collaborator: c,
+            collection: 'collaborators'
+          }
+        }))
+    )
+  }
+})
+
+function makeMarkup (...refs: Array<{ id: string, grantsAccess?: 'true' | 'false' }>): string {
+  return jsonToMarkup({
+    type: MarkupNodeType.doc,
+    content: refs.map((r) => ({
+      type: MarkupNodeType.reference,
+      attrs: {
+        id: r.id,
+        label: r.id,
+        objectclass: 'contact:class:Person',
+        ...(r.grantsAccess !== undefined ? { grantsAccess: r.grantsAccess } : {})
+      }
+    }))
+  })
+}
+
+const TARGET = { _id: 'issue-1', _class: 'tracker:class:Issue', space: 'space-1' }
+
+function makeControl (opts: { collab?: (query: any) => any[] } = {}): any {
+  return {
+    hierarchy: {
+      // ChunterTrigger dispatches on isDerived(tx.objectClass, ChatMessage)
+      // FIRST (index.ts:360) — without the ChatMessage branch OnChatMessageCreated
+      // never runs. Mentioned refs are Persons; ThreadMessage/Channel stay false.
+      isDerived: (cls: string, base: string) =>
+        (base === 'chunter:class:ChatMessage' && cls === 'chunter:class:ChatMessage') ||
+        (base === 'contact:class:Person' && cls === 'contact:class:Person')
+    },
+    modelDb: {},
+    txFactory: {
+      createTxCreateDoc: (_class: string, space: string, attributes: any) => ({
+        _class: coreDefault.class.TxCreateDoc,
+        objectClass: _class,
+        objectSpace: space,
+        attributes
+      })
+    },
+    findAll: jest.fn(async (_ctx: any, _class: string, query: any) => {
+      if (_class === coreDefault.class.Collaborator) {
+        // NON-EMPTY (default) -> skip the legacy init branch (index.ts:204) and
+        // provide the grant-target dedup basis (existing-acc already a collab).
+        // Tests that need the seed path (empty issue) pass an `opts.collab`
+        // override, query-aware on `query.attachedTo`.
+        return opts.collab != null ? opts.collab(query) : [{ collaborator: 'existing-acc' }]
+      }
+      if (_class === coreDefault.class.ClassCollaborators) {
+        return [{ provideSecurity: true }]
+      }
+      if (typeof _class === 'string' && _class.includes('Employee')) {
+        // Query-based: return an Employee for EVERY requested id. If the mock
+        // hardcoded only p1, the test would pass even WITHOUT the grantsAccess
+        // filter (p2 never returned) — a false positive. Returning all requested
+        // ids means a missing filter WOULD grant p2, so the test is red before
+        // Step 3 and green after.
+        const ids: string[] = query?._id?.$in ?? []
+        return ids.map((id: string) => ({ _id: id, personUuid: `${id}-acc` }))
+      }
+      if (_class === 'chunter:class:ChatMessage') {
+        // OnChatMessageUpdated loads the current stored message by _id before
+        // applying the update operations. Return a ChatMessage shape with the
+        // OLD (no-mention) body; the update tx supplies the new text.
+        return [
+          {
+            _id: 'msg-1',
+            _class: 'chunter:class:ChatMessage',
+            space: 'space-1',
+            attachedTo: TARGET._id,
+            attachedToClass: TARGET._class,
+            collection: 'comments',
+            message: makeMarkup(),
+            modifiedBy: 'social-author',
+            modifiedOn: 1
+          }
+        ]
+      }
+      // targetDoc lookup (message.attachedTo)
+      return [TARGET]
+    }),
+    ctx: {
+      with: async (_name: string, _params: any, fn: any) => fn({}),
+      contextData: {}
+    }
+  }
+}
+
+function makeCreateTx (markup: string): any {
+  return {
+    _class: coreDefault.class.TxCreateDoc,
+    objectClass: 'chunter:class:ChatMessage',
+    objectId: 'msg-1',
+    objectSpace: 'space-1',
+    modifiedBy: 'social-author',
+    attributes: {
+      attachedTo: TARGET._id,
+      attachedToClass: TARGET._class,
+      message: markup,
+      collection: 'comments'
+    }
+  }
+}
+
+function makeUpdateTx (operations: any, modifiedBy = 'social-editor'): any {
+  return {
+    _class: coreDefault.class.TxUpdateDoc,
+    objectClass: 'chunter:class:ChatMessage',
+    objectId: 'msg-1',
+    objectSpace: 'space-1',
+    modifiedBy,
+    modifiedOn: 2,
+    operations
+  }
+}
+
+function collaboratorGrants (res: Tx[]): string[] {
+  return res
+    .filter(
+      (t): t is TxCreateDoc<any> =>
+        t._class === coreDefault.class.TxCreateDoc && (t as any).objectClass === coreDefault.class.Collaborator
+    )
+    .map((t) => (t as any).attributes.collaborator)
+}
+
+describe('ChunterTrigger mention grants — grantsAccess filter', () => {
+  test("a reference with grantsAccess='false' yields no Collaborator tx for that person", async () => {
+    const control = makeControl()
+    const tx = makeCreateTx(makeMarkup({ id: 'p1' }, { id: 'p2', grantsAccess: 'false' }))
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    const granted = res
+      .filter(
+        (t): t is TxCreateDoc<any> =>
+          t._class === coreDefault.class.TxCreateDoc && (t as any).objectClass === coreDefault.class.Collaborator
+      )
+      .map((t) => (t as any).attributes.collaborator)
+
+    expect(granted).toContain('p1-acc') // p1 granted (no deny flag)
+    expect(granted).not.toContain('p2-acc') // p2 denied via grantsAccess='false'
+
+    // Stronger: the denied person must be filtered BEFORE the Employee query,
+    // so the query's id list must be exactly ['p1'] (not ['p1','p2']).
+    const employeeCall = control.findAll.mock.calls.find(
+      (c: any[]) => typeof c[1] === 'string' && c[1].includes('Employee')
+    )
+    expect(employeeCall?.[2]?._id?.$in).toEqual(['p1'])
+  })
+})
+
+describe('ChunterTrigger mention grants — V3d add-only re-grant on edit', () => {
+  test('a newly-added mention on edit grants the mentioned employee', async () => {
+    const control = makeControl()
+    const tx = makeUpdateTx({ message: makeMarkup({ id: 'p3' }) })
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    expect(collaboratorGrants(res)).toContain('p3-acc')
+  })
+
+  test('a denied mention on edit grants nothing (V3c filter still applies)', async () => {
+    const control = makeControl()
+    const tx = makeUpdateTx({ message: makeMarkup({ id: 'p3', grantsAccess: 'false' }) })
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    expect(collaboratorGrants(res)).not.toContain('p3-acc')
+  })
+
+  test('an already-granted collaborator is deduped — add-only no-op', async () => {
+    const control = makeControl()
+    // 'existing' resolves to personUuid 'existing-acc', which the grant target
+    // already lists (findAll Collaborator returns existing-acc) -> no new tx.
+    const tx = makeUpdateTx({ message: makeMarkup({ id: 'existing' }) })
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    expect(collaboratorGrants(res)).not.toContain('existing-acc')
+    expect(collaboratorGrants(res)).toHaveLength(0)
+  })
+
+  test('a System-authored edit grants nothing (stale modifiedBy guard — uses edit actor)', async () => {
+    const control = makeControl()
+    // updateDoc2Doc sets message.modifiedBy = tx.modifiedBy = System, so the
+    // applyMentionGrants System guard fires. If the handler used the stored
+    // doc's (non-System) author instead, this would wrongly grant.
+    const tx = makeUpdateTx({ message: makeMarkup({ id: 'p3' }) }, coreDefault.account.System)
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    expect(collaboratorGrants(res)).toHaveLength(0)
+  })
+
+  test('a non-message update (no operations.message) is a no-op', async () => {
+    const control = makeControl()
+    const tx = makeUpdateTx({ reactions: 1 })
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    expect(collaboratorGrants(res)).toHaveLength(0)
+  })
+})
+
+describe('ChunterTrigger mention grants — in-flight & self-mention dedup', () => {
+  test('Test A: self-mention yields exactly ONE Collaborator tx for the author', async () => {
+    // real duplicate on today's code: the author @-mentions themselves, so the
+    // author's uuid appears TWICE in collaboratorsFromMessage — once as the
+    // resolved Employee (id 'author' -> personUuid 'author-acc') and once as the
+    // `account` (getAccountBySocialId -> 'author-acc'). Before the in-loop dedup
+    // fix the grant branch pushes TWO identical TxCreateDoc<Collaborator>.
+    const control = makeControl()
+    const tx = makeCreateTx(makeMarkup({ id: 'author' }))
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    const authorGrants = collaboratorGrants(res).filter((c) => c === 'author-acc')
+    expect(authorGrants).toHaveLength(1) // before fix: 2
+  })
+
+  test('Test B: in-flight seed tx dedups the grant on the same target (future-fixed seed path)', async () => {
+    // FUTURE regression guard — this simulates a world where the seed lands on
+    // the Issue itself (getAddCollaboratTxes mock attaches to TARGET._id). It
+    // does NOT reflect today's runtime (today the seed attaches to the message).
+    // Empty issue + mention of an auto-collaborator: the seed creates a
+    // Collaborator(p5-acc, attachedTo issue-1) AND the grant loop would create a
+    // second Collaborator(p5-acc, attachedTo issue-1). The fix folds the
+    // in-flight seed tx into the dedup basis -> exactly one record survives.
+    ;(getDocCollaborators as jest.Mock).mockResolvedValueOnce(['p5-acc'])
+    // query-aware: empty for issue-1 (trigger seed + empty grant basis).
+    const control = makeControl({ collab: () => [] })
+    const tx = makeCreateTx(makeMarkup({ id: 'p5' }))
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    const p5Records = collaboratorGrants(res).filter((c) => c === 'p5-acc')
+    expect(p5Records).toHaveLength(1) // before fix: 2 (seed + grant)
+  })
+
+  test('Test C: seed tx on the child target does NOT dedup the grant on the ancestor', async () => {
+    // Thread delimitation — protects against the naive fix (dedup against ALL
+    // in-flight collaborator txes regardless of attachedTo). resolveMentionGrantTarget
+    // returns an ANCESTOR (epic-1) != targetDoc (issue-1). The seed attaches
+    // Collaborator(p9-acc) to the child issue-1; the grant must still be written
+    // for p9-acc on the ancestor epic-1 because the dedup basis is SCOPED to
+    // grantTarget._id.
+    const ANCESTOR = { _id: 'epic-1', _class: 'tracker:class:Issue', space: 'space-1' }
+    ;(resolveMentionGrantTarget as jest.Mock).mockImplementationOnce(async () => ANCESTOR)
+    ;(getDocCollaborators as jest.Mock).mockResolvedValueOnce(['p9-acc'])
+    const control = makeControl({ collab: () => [] })
+    const tx = makeCreateTx(makeMarkup({ id: 'p9' }))
+
+    const res: Tx[] = await ChunterTrigger([tx], control)
+
+    // Grant for p9-acc must exist on the ancestor epic-1 (not swallowed by the
+    // seed tx which is scoped to the child issue-1).
+    const grantOnAncestor = res.filter(
+      (t: any) =>
+        t._class === coreDefault.class.TxCreateDoc &&
+        t.objectClass === coreDefault.class.Collaborator &&
+        t.attributes.attachedTo === 'epic-1' &&
+        t.attributes.collaborator === 'p9-acc'
+    )
+    expect(grantOnAncestor).toHaveLength(1)
+  })
+})
diff --git a/server-plugins/chunter-resources/src/index.ts b/server-plugins/chunter-resources/src/index.ts
index 91896f6654c..e49ea7f7079 100644
--- a/server-plugins/chunter-resources/src/index.ts
+++ b/server-plugins/chunter-resources/src/index.ts
@@ -37,7 +37,9 @@ import core, {
   TxUpdateDoc,
   UserStatus,
   getClassCollaborators,
-  type MeasureContext
+  resolveMentionGrantTarget,
+  type MeasureContext,
+  type Collaborator
 } from '@hcengineering/core'
 import notification, { DocNotifyContext, NotificationContent } from '@hcengineering/notification'
 import { getMetadata, IntlString, translate } from '@hcengineering/platform'
@@ -187,6 +189,7 @@ async function OnChatMessageCreated (ctx: MeasureContext, tx: TxCUD<Doc>, contro
   const references = extractReferences(node)
   const mentionedPersons = references
     .filter(({ objectClass }) => control.hierarchy.isDerived(objectClass, contact.class.Person))
+    .filter(({ grantsAccess }) => grantsAccess !== 'false') // V3c: skip explicitly-denied mentions
     .map(({ objectId }) => objectId as Ref<Person>)
   const employees =
     mentionedPersons.length > 0
@@ -208,25 +211,80 @@ async function OnChatMessageCreated (ctx: MeasureContext, tx: TxCUD<Doc>, contro
     }
   }
 
-  const classCollab = (
-    await control.findAll(control.ctx, core.class.ClassCollaborators, { attachedTo: targetDoc._class })
+  // Resolve the Doc the mention-Collaborator records should land on.
+  //   - targetDoc has provideSecurity:true && mentionsGrantAccess:true:
+  //     helper returns targetDoc itself → grants access on that doc.
+  //   - targetDoc unprotected, but its attachedTo chain reaches an opted-in
+  //     ancestor (e.g. ThreadMessage → ChatMessage → Issue): helper returns
+  //     that ancestor → grants access on the Issue, not the thread.
+  //   - nothing in the chain is opted in: helper returns null.
+  // The grant-target branch writes Collaborator on the resolved doc and
+  // dedups against THAT doc's collaborator list (not against targetDoc's,
+  // which is the wrong basis when targetDoc is a child like ThreadMessage).
+  const grantTarget = await resolveMentionGrantTarget(targetDoc, (cls, q, o) => control.findAll(control.ctx, cls, q, o))
+  const targetClassCollab = (
+    await control.findAll(control.ctx, core.class.ClassCollaborators, { attachedTo: targetDoc._class }, { limit: 1 })
   )[0]
-  if (classCollab?.provideSecurity !== true) {
+  const isProtectedTarget = targetClassCollab?.provideSecurity === true
+
+  if (grantTarget != null) {
+    const grantCollabs = (
+      await control.findAll<Collaborator>(control.ctx, core.class.Collaborator, {
+        attachedTo: grantTarget._id
+      })
+    ).map((c) => c.collaborator)
+
+    // Dedup basis = committed collaborators on grantTarget UNION Collaborator
+    // TxCreateDoc already queued in `res` for this same grantTarget (e.g. the
+    // seed block above, or a prior loop iteration). Scoped to grantTarget._id so
+    // seed txes attached to a child doc (ThreadMessage/message) never suppress a
+    // grant on the resolved ancestor. The in-loop `granted.add` also collapses
+    // the real self-mention duplicate — collaboratorsFromMessage carries the
+    // author uuid twice (once as Employee, once as `account`).
+    const granted = new Set<AccountUuid>(grantCollabs)
+    for (const t of res) {
+      if (t._class === core.class.TxCreateDoc && (t as TxCUD<Doc>).objectClass === core.class.Collaborator) {
+        const attrs = (t as TxCreateDoc<Collaborator>).attributes
+        if (attrs.attachedTo === grantTarget._id) {
+          granted.add(attrs.collaborator)
+        }
+      }
+    }
+
+    for (const collab of collaboratorsFromMessage) {
+      if (granted.has(collab)) {
+        continue
+      }
+      granted.add(collab)
+      res.push(
+        control.txFactory.createTxCreateDoc(core.class.Collaborator, grantTarget.space, {
+          attachedTo: grantTarget._id,
+          attachedToClass: grantTarget._class,
+          collaborator: collab,
+          collection: 'collaborators'
+        })
+      )
+    }
+  } else if (!isProtectedTarget) {
+    // Legacy notification-routing path: targetDoc is not provideSecurity,
+    // so Collaborator records here are purely for notification fan-out
+    // (today's behavior for Channels, DirectMessages, etc.).
     for (const collab of collaboratorsFromMessage) {
       if (currentCollaborators.includes(collab)) {
         continue
       }
-
-      const tx = control.txFactory.createTxCreateDoc(core.class.Collaborator, targetDoc.space, {
-        attachedTo: targetDoc._id,
-        attachedToClass: targetDoc._class,
-        collaborator: collab,
-        collection: 'collaborators'
-      })
-
-      res.push(tx)
+      res.push(
+        control.txFactory.createTxCreateDoc(core.class.Collaborator, targetDoc.space, {
+          attachedTo: targetDoc._id,
+          attachedToClass: targetDoc._class,
+          collaborator: collab,
+          collection: 'collaborators'
+        })
+      )
     }
   }
+  // Else: protected target without mentionsGrantAccess (QMS / Love today)
+  // → no-op, preserving pre-PR behavior for those classes.
 
   if (account != null && isChannel && !(targetDoc as Channel).members.includes(account)) {
     res.push(...joinChannel(control, targetDoc as Channel, account))
@@ -235,6 +293,83 @@ async function OnChatMessageCreated (ctx: MeasureContext, tx: TxCUD<Doc>, contro
   return res
 }
 
+// V3d: self-contained grant helper used ONLY by OnChatMessageUpdated.
+// Do NOT refactor OnChatMessageCreated to call this — the create path is live-tested
+// and must remain provably unchanged. The ~25-line overlap is intentional.
+async function applyMentionGrants (ctx: MeasureContext, message: ChatMessage, control: TriggerControl): Promise<Tx[]> {
+  if (message.modifiedBy === core.account.System) return []
+  const mixin = getClassCollaborators(control.modelDb, control.hierarchy, message.attachedToClass)
+  if (mixin === undefined) return []
+
+  const targetDoc = (await control.findAll(ctx, message.attachedToClass, { _id: message.attachedTo }, { limit: 1 }))[0]
+  if (targetDoc === undefined) return []
+
+  const node = markupToJSON(message.message)
+  const references = extractReferences(node)
+  const mentionedPersons = references
+    .filter(({ objectClass }) => control.hierarchy.isDerived(objectClass, contact.class.Person))
+    .filter(({ grantsAccess }) => grantsAccess !== 'false') // V3c
+    .map(({ objectId }) => objectId as Ref<Person>)
+  // V3d is "a newly-added mention grants access". With no granting mention there
+  // is nothing to do — return early so a plain text edit never re-runs grant
+  // machinery, and the author is NOT re-added as a collaborator on every edit.
+  if (mentionedPersons.length === 0) return []
+  const employees = await control.findAll(ctx, contact.mixin.Employee, {
+    _id: { $in: mentionedPersons as Ref<Employee>[] }
+  })
+  // Update path grants ONLY the mentioned employees (not the author — the
+  // author was already added at create time; the create path is unchanged).
+  const collaboratorsFromMessage = employees.map((it) => it.personUuid).filter(notEmpty)
+  if (collaboratorsFromMessage.length === 0) return []
+
+  const grantTarget = await resolveMentionGrantTarget(targetDoc, (cls, q, o) => control.findAll(control.ctx, cls, q, o))
+  if (grantTarget == null) return [] // update-grant only applies to opted-in (protected) targets
+
+  const grantCollabs = (
+    await control.findAll<Collaborator>(control.ctx, core.class.Collaborator, { attachedTo: grantTarget._id })
+  ).map((c) => c.collaborator)
+
+  // Same dedup discipline as the create path: a Set seeded from the committed
+  // collaborators, updated in-loop so a person mentioned more than once within one
+  // edit (two refs resolving to the same account) can never emit two identical
+  // Collaborator txes. Unlike the create path, the author is not appended here, so a
+  // self-mention alone is not a duplicate source in this path.
+  const granted = new Set<AccountUuid>(grantCollabs)
+  const res: Tx[] = []
+  for (const collab of collaboratorsFromMessage) {
+    if (granted.has(collab)) continue // add-only: skip existing
+    granted.add(collab)
+    res.push(
+      control.txFactory.createTxCreateDoc(core.class.Collaborator, grantTarget.space, {
+        attachedTo: grantTarget._id,
+        attachedToClass: grantTarget._class,
+        collaborator: collab,
+        collection: 'collaborators'
+      })
+    )
+  }
+  return res
+}
+
+async function OnChatMessageUpdated (ctx: MeasureContext, tx: TxCUD<Doc>, control: TriggerControl): Promise<Tx[]> {
+  const actualTx = tx as TxUpdateDoc<ChatMessage>
+  // Only act when the message body changed (a new mention may have been added).
+  if (actualTx.operations.message === undefined) return []
+
+  const current = (await control.findAll(ctx, tx.objectClass, { _id: tx.objectId }, { limit: 1 }))[0] as
+    | ChatMessage
+    | undefined
+  if (current === undefined) return []
+
+  // Apply the update to the stored doc so the message text AND the actor
+  // (modifiedBy) reflect THIS edit — not the original author. applyMentionGrants
+  // guards on message.modifiedBy === System, so it must see the edit actor.
+  // Add-only: we grant for all currently-mentioned people; existing grants dedup
+  // to no-ops, and we never remove (Collaborator has no provenance to remove by).
+  const message = TxProcessor.updateDoc2Doc({ ...current }, actualTx)
+  return await applyMentionGrants(ctx, message, control)
+}
+
 async function ChatNotificationsHandler (txes: TxCUD<Doc>[], control: TriggerControl): Promise<Tx[]> {
   const result: Tx[] = []
   for (const tx of txes) {
@@ -322,6 +457,12 @@ export async function ChunterTrigger (txes: TxCUD<Doc>[], control: TriggerContro
     ) {
       res.push(...(await control.ctx.with('OnChatMessageCreated', {}, (ctx) => OnChatMessageCreated(ctx, tx, control))))
     }
+    if (
+      tx._class === core.class.TxUpdateDoc &&
+      control.hierarchy.isDerived(tx.objectClass, chunter.class.ChatMessage)
+    ) {
+      res.push(...(await control.ctx.with('OnChatMessageUpdated', {}, (ctx) => OnChatMessageUpdated(ctx, tx, control))))
+    }
   }
   return res
 }
diff --git a/tests/sanity/tests/model/tracker/common-tracker-page.ts b/tests/sanity/tests/model/tracker/common-tracker-page.ts
index 2252500c13e..992b6fafc13 100644
--- a/tests/sanity/tests/model/tracker/common-tracker-page.ts
+++ b/tests/sanity/tests/model/tracker/common-tracker-page.ts
@@ -174,6 +174,14 @@ export class CommonTrackerPage extends CalendarPage {
     await this.inputComment().fill(`@${mention}`)
     await this.selectMention(mention)
     await this.buttonSendComment().click()
+    // V3 mention-grants: when the mentioned person is not already a member of
+    // the issue's grant target, sending opens a disclosure dialog. Confirm it
+    // with "Send with selected grants" so the comment actually gets sent and
+    // the test doesn't hang waiting for the assertion.
+    const confirm = this.page.getByRole('button', { name: 'Send with selected grants' })
+    if (await confirm.isVisible({ timeout: 1000 }).catch(() => false)) {
+      await confirm.click()
+    }
   }
 
   async checkActivityContentExist (activityContent: string): Promise<void> {
diff --git a/tests/sanity/tests/tracker/mention-grants-closed-issue.spec.ts b/tests/sanity/tests/tracker/mention-grants-closed-issue.spec.ts
new file mode 100644
index 00000000000..73f1a5646dc
--- /dev/null
+++ b/tests/sanity/tests/tracker/mention-grants-closed-issue.spec.ts
@@ -0,0 +1,63 @@
+import { test } from '@playwright/test'
+import { generateId, PlatformSetting, PlatformURI } from '../utils'
+import { IssuesPage } from '../model/tracker/issues-page'
+import { IssuesDetailsPage } from '../model/tracker/issues-details-page'
+import { TrackerNavigationMenuPage } from '../model/tracker/tracker-navigation-menu-page'
+import { NewIssue } from '../model/tracker/types'
+
+test.use({
+  storageState: PlatformSetting
+})
+
+test.describe('mention-grants — closed issue access', () => {
+  let trackerNav: TrackerNavigationMenuPage
+  let issuesPage: IssuesPage
+  let issuesDetailsPage: IssuesDetailsPage
+
+  test.beforeEach(async ({ page }) => {
+    trackerNav = new TrackerNavigationMenuPage(page)
+    issuesPage = new IssuesPage(page)
+    issuesDetailsPage = new IssuesDetailsPage(page)
+
+    await (await page.goto(`${PlatformURI}/workbench/sanity-ws`))?.finished()
+  })
+
+  test('mentioned user remains a Collaborator after the issue is moved to Done', async ({ page }) => {
+    const issue: NewIssue = {
+      title: `V2 closed-issue mention-grant-${generateId()}`,
+      description: 'Mention a user, then close the issue; the mention-grant must persist.'
+    }
+
+    // Navigate to the Default project's issues list and show all issues.
+    // openIssuesForProject + clickModelSelectorAll mirrors the pattern used
+    // by issues-duplicate.spec.ts and attachments.spec.ts.
+    await trackerNav.openIssuesForProject('Default')
+    await issuesPage.clickModelSelectorAll()
+
+    await issuesPage.createNewIssue(issue)
+    await issuesPage.searchIssueByName(issue.title)
+    await issuesPage.openIssueByName(issue.title)
+
+    // Mention a user via the real mention picker (Dirak Kainin is the seed
+    // contact used by the existing mentions.spec.ts:37). addMentions() opens
+    // the @-popup and selects the match — addComment() would only send literal
+    // text and would NOT create a reference node.
+    await issuesDetailsPage.addMentions('Dirak Kainin')
+
+    // Move the issue to Done. editIssue accepts a partial Issue; the status
+    // field clicks the status button and selects from the dropdown.
+    await issuesDetailsPage.editIssue({ status: 'Done' })
+
+    // Reload and confirm the mentioned user is listed under Collaborators.
+    // The issue author ('Appleseed John') and the mentioned user ('Dirak Kainin')
+    // must both be present — this mirrors the assertion in mentions.spec.ts:40.
+    await page.reload()
+    await issuesDetailsPage.checkCollaborators(['Appleseed John', 'Dirak Kainin'])
+  })
+})
+
+// TODO (V2b): add a guest storage state and assert the issue is visible +
+// commentable from the guest's own session. The above test covers the
+// server-side grant (Collaborator record exists) which is the actual
+// regression risk; the guest-perspective UI walk needs a second authenticated
+// Playwright storage state.