@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.7

package/src/__tests__/realtimeRecordingHandler.test.ts

@@ -25,6 +25,7 @@ import {
     CreateRealtimeRecordingRouter, FINAL_TERMINAL_RECHECK_MS, REALTIME_RECORDING_MOUNT_PATH, type RealtimeRecordingRouterDeps,
 } from '../rest/RealtimeRecordingHandler.js';
 import { RealtimeSessionNotFoundError, RealtimeSessionOwnershipError } from '../realtimeSessions/ownedRealtimeSession.js';
+import { AuthorizeSessionAccess } from '../realtimeSessions/sessionAccess.js';
 import { RecordingAssemblyScheduler, type IRecordingAssemblyScheduler } from '../realtimeSessions/RecordingAssemblyScheduler.js';
 
 const SESSION = '11111111-1111-4111-8111-111111111111';
@@ -135,6 +136,10 @@ class FakeLedger implements IRealtimeRecordingLedger {
         throw new Error('not used by the routes');
     }
 
+    public async StampFile(): Promise<{ RecordingStatus: string | null }> {
+        throw new Error('not used by the routes');
+    }
+
     public async LoadShards(sessionID: string): Promise<LedgerShard[]> {
         return [...this.shardsOf(sessionID).values()].sort((a, b) => a.Index - b.Index)
             .map(s => ({ Index: s.Index, StartSample: s.StartSample, SampleCount: s.SampleCount, Data: s.Data }));
@@ -198,6 +203,7 @@ function callerLedger(inner: FakeLedger): IRealtimeRecordingLedger {
         ClaimAssembly: id => inner.ClaimAssembly(id),
         FinishAssembly: input => inner.FinishAssembly(input),
         StampAssemblyGaps: () => inner.StampAssemblyGaps(),
+        StampFile: () => inner.StampFile(),
         LoadShards: refuse,
         LoadShardMetadata: refuse,
         CountShardsBelow: refuse,
@@ -221,7 +227,7 @@ describe('realtime recording REST routes', () => {
         const app = express();
         app.use(REALTIME_RECORDING_MOUNT_PATH, CreateRealtimeRecordingRouter(deps));
         server = await new Promise<Server>(resolve => {
-            const s = app.listen(0, () => resolve(s));
+            const s = app.listen(0, '127.0.0.1', () => resolve(s));
         });
         baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}${REALTIME_RECORDING_MOUNT_PATH}`;
     }
@@ -264,11 +270,19 @@ describe('realtime recording REST routes', () => {
                 const user = {
                     ID: id,
                     IsMagicLinkAnonymous: req.header('x-test-anonymous') === 'true',
+                    AnonymousVisitorID: scope ?? undefined,
                     MagicLinkScope: scope ? { ResourceID: scope } : undefined,
                 };
                 return id ? { ContextUser: user as unknown as UserInfo, Provider: {} as unknown as DatabaseProviderBase } : null;
             },
-            LoadConversationExternalID: async session => ledger.Sessions.get(session.ID)?.ConversationExternalID ?? null,
+            // The real scope rule over this test's conversation rows (no database behind them).
+            AuthorizeSession: async (session, contextUser) => {
+                const row = ledger.Sessions.get(session.ID);
+                return AuthorizeSessionAccess(
+                    { SessionUserID: session.UserID, ConversationExternalID: row?.ConversationExternalID ?? null, ConversationReadable: row?.ConversationExternalID !== undefined },
+                    contextUser,
+                );
+            },
             LoadOwnedSession: async (agentSessionId, contextUser) => {
                 const row = ledger.Sessions.get(agentSessionId);
                 if (!row) {
@@ -391,6 +405,14 @@ describe('realtime recording REST routes', () => {
                 expect((await post(`/${SESSION}/end?lastShardIndex=0&capturedSamples=${SHARD_SAMPLES}`, null, OWNER_ID, headers)).status).toBe(200);
             });
 
+            it('accepts a named owner holding a resource-scoped link on its own unstamped conversation, and refuses another stamp (#4931)', async () => {
+                const headers = { 'x-test-scope': 'res-1' };
+                addSession(SESSION, { ConversationExternalID: null });
+                expect((await post(`/${SESSION}/shard/0`, shardBytes(0), OWNER_ID, headers)).status).toBe(200);
+                addSession(SESSION, { ConversationExternalID: 'res-2' });
+                expect((await post(`/${SESSION}/shard/1`, shardBytes(1), OWNER_ID, headers)).status).toBe(403);
+            });
+
             it('leaves a named owner (no scope, not anonymous) unaffected', async () => {
                 expect((await postShard(0)).status).toBe(200);
             });

package/src/__tests__/realtimeSessions/RealtimeSessionEventsResolver.test.ts

@@ -27,7 +27,12 @@ function contextFor(user: Partial<UserInfo> & { ID: string }): RealtimeSessionEv
 
 const named = (id: string) => contextFor({ ID: id });
 const guest = (id: string, scope?: string) =>
-    contextFor({ ID: id, IsMagicLinkAnonymous: true, MagicLinkScope: scope ? { ResourceID: scope } : undefined } as Partial<UserInfo> & { ID: string });
+    contextFor({
+        ID: id,
+        IsMagicLinkAnonymous: true,
+        AnonymousVisitorID: scope,
+        MagicLinkScope: scope ? { ResourceID: scope } : undefined,
+    } as Partial<UserInfo> & { ID: string });
 
 function event(over: Partial<RealtimeSessionEventTopicPayload> = {}): RealtimeSessionEventTopicPayload {
     return {
@@ -75,6 +80,18 @@ describe('RealtimeSessionEventsFilter (per-event gate)', () => {
         });
     });
 
+    describe('a named user holding a resource-scoped magic link (#4931)', () => {
+        const namedScoped = (scope: string) => contextFor({ ID: OWNER, MagicLinkScope: { ResourceID: scope } } as Partial<UserInfo> & { ID: string });
+
+        it('delivers its own session\'s events when the conversation carries no scope stamp', () => {
+            expect(filter(event({ ScopeKey: null }), SESSION_ID, namedScoped('res-1'))).toBe(true);
+        });
+
+        it('does not deliver events of a session stamped with its other link\'s scope', () => {
+            expect(filter(event({ ScopeKey: 'res-2' }), SESSION_ID, namedScoped('res-1'))).toBe(false);
+        });
+    });
+
     it('fails closed on a missing connection identity, owner or argument', () => {
         expect(filter(event(), SESSION_ID, undefined)).toBe(false);
         expect(filter(event(), SESSION_ID, { userPayload: undefined })).toBe(false);
@@ -98,6 +115,17 @@ describe('AuthorizeRealtimeSessionSubscription (subscribe-time gate)', () => {
         expect(d.LoadSession).toHaveBeenCalledWith(SESSION_ID, expect.objectContaining({ ID: OWNER }), expect.anything());
     });
 
+    it('lets a named scoped owner subscribe to its session on a readable, unstamped conversation, and refuses it when unreadable (#4931)', async () => {
+        const namedScoped = contextFor({ ID: OWNER, MagicLinkScope: { ResourceID: 'res-1' } } as Partial<UserInfo> & { ID: string });
+        const load = (readable: boolean): SubscriptionAuthorizationDeps => ({
+            LoadSession: vi.fn(async () =>
+                ({ Session: { ID: SESSION_ID, UserID: OWNER }, ConversationExternalID: null, ConversationReadable: readable } as unknown as LoadedSessionForAccess)),
+            GetProvider: () => ({}) as IMetadataProvider,
+        });
+        await expect(AuthorizeRealtimeSessionSubscription({ agentSessionId: SESSION_ID }, namedScoped, load(true))).resolves.toBe(SESSION_ID);
+        await expect(AuthorizeRealtimeSessionSubscription({ agentSessionId: SESSION_ID }, namedScoped, load(false))).rejects.toThrow('Realtime session not found.');
+    });
+
     it('refuses a non-owner with the uniform not-found message', async () => {
         await expect(AuthorizeRealtimeSessionSubscription({ agentSessionId: SESSION_ID }, named(STRANGER), deps({ UserID: OWNER, ExternalID: null }))).rejects.toThrow('Realtime session not found.');
     });

package/src/__tests__/realtimeSessions/ownedRealtimeSession.anonymous.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { LoadOwnedRealtimeSession, RealtimeSessionOwnershipError } from '../../realtimeSessions/ownedRealtimeSession.js';
+
+// Fixture UUIDs are assembled at runtime so the brief itself carries no record id.
+const uuid = (a: string, b: string) => [a.repeat(8), b.repeat(4), '4' + b.repeat(3), '8' + b.repeat(3), b.repeat(12)].join('-');
+const ANON = uuid('A', '0');
+const SESSION = uuid('1', '1');
+const CONVERSATION = uuid('2', '2');
+const guest = (scope: string) =>
+    ({ ID: ANON, IsMagicLinkAnonymous: true, AnonymousVisitorID: scope, MagicLinkScope: { ResourceID: scope } } as unknown as UserInfo);
+
+/** A session owned by the shared Anonymous user; its conversation is stamped with visitor 1's scope. */
+function provider(): IMetadataProvider {
+    return {
+        GetEntityObject: vi.fn(async (entity: string) =>
+            entity === 'MJ: AI Agent Sessions'
+                ? { UserID: ANON, ConversationID: CONVERSATION, Load: vi.fn(async () => true) }
+                : { ExternalID: 'scope-visitor-1', Load: vi.fn(async () => true) }),
+    } as unknown as IMetadataProvider;
+}
+
+describe('LoadOwnedRealtimeSession with two anonymous visitors', () => {
+    it('allows the visitor whose scope matches', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, guest('scope-visitor-1'), provider())).resolves.toBeDefined();
+    });
+    it('refuses a second anonymous visitor (same Anonymous user id, different scope)', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, guest('scope-visitor-2'), provider()))
+            .rejects.toBeInstanceOf(RealtimeSessionOwnershipError);
+    });
+});

package/src/__tests__/realtimeSessions/ownedRealtimeSession.namedScoped.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { LoadOwnedRealtimeSession, RealtimeSessionOwnershipError } from '../../realtimeSessions/ownedRealtimeSession.js';
+
+// Fixture UUIDs are assembled at runtime so no literal record id appears in the source.
+const uuid = (a: string, b: string) => [a.repeat(8), b.repeat(4), '4' + b.repeat(3), '8' + b.repeat(3), b.repeat(12)].join('-');
+const NAMED = uuid('B', '1');
+const SESSION = uuid('1', '1');
+const CONVERSATION = uuid('2', '2');
+
+/** A named magic-link user (found by email) holding a link scoped to `scope`. */
+const namedScoped = (scope: string) => ({ ID: NAMED, IsMagicLinkAnonymous: false, MagicLinkScope: { ResourceID: scope } } as unknown as UserInfo);
+
+/** The named user's own session; its conversation loads with `externalID`, or not at all when `readable` is false. */
+function provider(externalID: string | null, readable = true): IMetadataProvider {
+    return {
+        GetEntityObject: vi.fn(async (entity: string) =>
+            entity === 'MJ: AI Agent Sessions'
+                ? { UserID: NAMED, ConversationID: CONVERSATION, Load: vi.fn(async () => true) }
+                : { ExternalID: externalID, Load: vi.fn(async () => readable) }),
+    } as unknown as IMetadataProvider;
+}
+
+describe('LoadOwnedRealtimeSession for a named user with a resource-scoped link', () => {
+    it('allows its own session on a conversation it can read that carries no scope stamp (one started from the Conversations app)', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, namedScoped('res-1'), provider(null))).resolves.toBeDefined();
+    });
+    it('allows its own session on a conversation stamped with the same scope', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, namedScoped('res-1'), provider('res-1'))).resolves.toBeDefined();
+    });
+    it('refuses its own session on a conversation stamped with another scope (a session from its other link)', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, namedScoped('res-2'), provider('res-1'))).rejects.toBeInstanceOf(RealtimeSessionOwnershipError);
+    });
+    it('refuses when it cannot read the conversation (fail closed)', async () => {
+        await expect(LoadOwnedRealtimeSession(SESSION, namedScoped('res-1'), provider(null, false))).rejects.toBeInstanceOf(RealtimeSessionOwnershipError);
+    });
+});

package/src/__tests__/realtimeSessions/sessionAccess.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
-import { AuthorizeSessionAccess, LoadSessionForAccess } from '../../realtimeSessions/sessionAccess.js';
+import type { MJAIAgentSessionEntity } from '@memberjunction/core-entities';
+import { AuthorizeSessionAccess, AuthorizeConversationTurn, AuthorizeAnonymousRoomSessions, LoadSessionForAccess, LoadSessionConversationScope, LoadConversationScope, AuthorizeLoadedSession } from '../../realtimeSessions/sessionAccess.js';
 
 const OWNER = 'AAAAAAAA-0000-4000-8000-000000000001';
 const OTHER = 'AAAAAAAA-0000-4000-8000-000000000002';
@@ -27,27 +28,57 @@ describe('AuthorizeSessionAccess', () => {
         expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null }, { ID: '' })).toEqual({ Allowed: false, Reason: 'not_owner' });
     });
 
-    describe('anonymous widget guests (one shared Anonymous user)', () => {
-        const guest = (scope?: string) => ({ ID: OWNER, IsMagicLinkAnonymous: true, MagicLinkScope: scope ? { ResourceID: scope } : undefined });
+    describe('anonymous visitors (one shared Anonymous user, per-visitor AnonymousVisitorID)', () => {
+        const guest = (visitorId?: string, resourceScope?: string) => ({
+            ID: OWNER,
+            IsMagicLinkAnonymous: true,
+            AnonymousVisitorID: visitorId,
+            MagicLinkScope: resourceScope ? { ResourceID: resourceScope } : visitorId ? { ResourceID: visitorId } : undefined,
+        });
 
-        it('allows a guest whose signed scope matches the conversation ExternalID', () => {
+        it('allows a visitor whose AnonymousVisitorID matches the conversation ExternalID', () => {
             expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'scope-1' }, guest('scope-1'))).toEqual({ Allowed: true });
         });
 
-        it('refuses a different guest (same Anonymous user id, different scope) — the cross-guest leak', () => {
+        it('refuses a different widget guest (same Anonymous user id, different visitor id) — the cross-guest leak', () => {
             expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'scope-1' }, guest('scope-2'))).toEqual({
                 Allowed: false,
                 Reason: 'scope_mismatch',
             });
         });
 
-        it('refuses an anonymous principal with no scope at all', () => {
-            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'scope-1' }, guest())).toEqual({
+        it('refuses an anonymous principal with neither a resource scope nor an AnonymousVisitorID', () => {
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'scope-1' }, guest(undefined))).toEqual({
                 Allowed: false,
                 Reason: 'scope_missing',
             });
         });
 
+        describe('identity per token kind: MagicLinkScope.ResourceID when the token carries one, else mj_sid', () => {
+            it('widget guest (ResourceID == mj_sid): matches its own sessionId', () => {
+                expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'sid-w' }, guest('sid-w', 'sid-w'))).toEqual({ Allowed: true });
+            });
+
+            it('anonymous invite WITH a ResourceID: identity is the ResourceID, not its per-redemption mj_sid', () => {
+                const visitor = guest('sid-redemption-1', 'invite-scope-R');
+                expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'invite-scope-R' }, visitor)).toEqual({ Allowed: true });
+                expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'sid-redemption-1' }, visitor)).toEqual({
+                    Allowed: false,
+                    Reason: 'scope_mismatch',
+                });
+            });
+
+            it('anonymous invite WITHOUT a ResourceID: identity is mj_sid, so two redemptions are told apart', () => {
+                const first = { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-r1' };
+                const second = { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-r2' };
+                expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'sid-r1' }, first)).toEqual({ Allowed: true });
+                expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'sid-r1' }, second)).toEqual({
+                    Allowed: false,
+                    Reason: 'scope_mismatch',
+                });
+            });
+        });
+
         it('refuses when the conversation carries no scope id (unreadable or unscoped)', () => {
             expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null }, guest('scope-1'))).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
             expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: undefined }, guest('scope-1'))).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
@@ -68,6 +99,28 @@ describe('AuthorizeSessionAccess', () => {
         expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'other' }, scoped)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
     });
 
+    describe('a NAMED principal with a resource scope on a conversation with no scope stamp', () => {
+        const scoped = { ID: OWNER, MagicLinkScope: { ResourceID: 'share-1' } };
+
+        it('is allowed when it could read the conversation (e.g. one started from the Conversations app)', () => {
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null, ConversationReadable: true }, scoped)).toEqual({ Allowed: true });
+        });
+
+        it('is refused when it could not read the conversation, or readability is unknown (fail closed)', () => {
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null, ConversationReadable: false }, scoped)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null }, scoped)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+        });
+
+        it('still refuses a conversation stamped with another scope, readable or not', () => {
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'share-2', ConversationReadable: true }, scoped)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+        });
+
+        it('does not extend to an anonymous visitor, which an unstamped conversation cannot identify', () => {
+            const visitor = { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-1' };
+            expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: null, ConversationReadable: true }, visitor)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+        });
+    });
+
     it('does not require a scope of a named principal without one, whatever the conversation says', () => {
         expect(AuthorizeSessionAccess({ SessionUserID: OWNER, ConversationExternalID: 'scope-1' }, { ID: OWNER })).toEqual({ Allowed: true });
     });
@@ -99,6 +152,7 @@ describe('LoadSessionForAccess', () => {
         const loaded = await LoadSessionForAccess(SESSION_ID, USER, provider);
         expect(loaded?.Session.ID).toBe(SESSION_ID);
         expect(loaded?.ConversationExternalID).toBe('scope-1');
+        expect(loaded?.ConversationReadable).toBe(true);
     });
 
     it('returns null for a malformed id without touching the database', async () => {
@@ -114,16 +168,179 @@ describe('LoadSessionForAccess', () => {
     it('reports a null scope id when the session has no conversation', async () => {
         const loaded = await LoadSessionForAccess(SESSION_ID, USER, fakeProvider({ session: { ID: SESSION_ID, UserID: OWNER, ConversationID: null } }));
         expect(loaded?.ConversationExternalID).toBeNull();
+        expect(loaded?.ConversationReadable).toBe(false);
     });
 
     it('reports a null scope id when the conversation is unreadable, so a scoped caller is refused downstream', async () => {
         const unreadable = await LoadSessionForAccess(SESSION_ID, USER, fakeProvider({ session: { ID: SESSION_ID, UserID: OWNER, ConversationID: CONVERSATION_ID }, conversation: null }));
         expect(unreadable?.ConversationExternalID).toBeNull();
+        expect(unreadable?.ConversationReadable).toBe(false);
         const throwing = await LoadSessionForAccess(
             SESSION_ID,
             USER,
             fakeProvider({ session: { ID: SESSION_ID, UserID: OWNER, ConversationID: CONVERSATION_ID }, conversation: {}, conversationThrows: true }),
         );
         expect(throwing?.ConversationExternalID).toBeNull();
+        expect(throwing?.ConversationReadable).toBe(false);
+    });
+
+    it('reports a readable conversation that carries no scope stamp', async () => {
+        const loaded = await LoadSessionForAccess(SESSION_ID, USER, fakeProvider({ session: { ID: SESSION_ID, UserID: OWNER, ConversationID: CONVERSATION_ID }, conversation: { ExternalID: null } }));
+        expect(loaded?.ConversationExternalID).toBeNull();
+        expect(loaded?.ConversationReadable).toBe(true);
+    });
+});
+
+describe('LoadSessionConversationScope', () => {
+    const sessionWithConversation = { ID: SESSION_ID, UserID: OWNER, ConversationID: CONVERSATION_ID } as unknown as MJAIAgentSessionEntity;
+
+    it('reads the conversation for an unscoped named user too, so its result is the conversation as that user sees it', async () => {
+        const provider = fakeProvider({ conversation: { ExternalID: 'scope-1' } });
+        const scope = await LoadSessionConversationScope(sessionWithConversation, USER, provider);
+        expect(scope).toEqual({ ExternalID: 'scope-1', Readable: true });
+        expect(provider.GetEntityObject).toHaveBeenCalledTimes(1);
+    });
+
+    it('reads the conversation when the caller carries a scope identity', async () => {
+        const scopedUser = { ID: OWNER, MagicLinkScope: { ResourceID: 'scope-1' } } as unknown as UserInfo;
+        const provider = fakeProvider({ conversation: { ExternalID: 'scope-1' } });
+        const scope = await LoadSessionConversationScope(sessionWithConversation, scopedUser, provider);
+        expect(scope).toEqual({ ExternalID: 'scope-1', Readable: true });
+        expect(provider.GetEntityObject).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('LoadConversationScope (a conversation addressed directly, e.g. by a text agent turn)', () => {
+    it('reports the owner and scope id of a readable conversation', async () => {
+        const scope = await LoadConversationScope(CONVERSATION_ID, USER, fakeProvider({ conversation: { UserID: OWNER, ExternalID: 'scope-1' } }));
+        expect(scope).toEqual({ UserID: OWNER, ExternalID: 'scope-1', Readable: true });
+    });
+
+    it('reports an unreadable conversation (missing, refused by RLS, or a failed read) without an owner', async () => {
+        expect(await LoadConversationScope(CONVERSATION_ID, USER, fakeProvider({ conversation: null }))).toEqual({ UserID: null, ExternalID: null, Readable: false });
+        expect(await LoadConversationScope(CONVERSATION_ID, USER, fakeProvider({ conversation: {}, conversationThrows: true }))).toEqual({ UserID: null, ExternalID: null, Readable: false });
+    });
+
+    it('reports a null scope id for a readable conversation with no stamp', async () => {
+        const scope = await LoadConversationScope(CONVERSATION_ID, USER, fakeProvider({ conversation: { UserID: OWNER, ExternalID: null } }));
+        expect(scope).toEqual({ UserID: OWNER, ExternalID: null, Readable: true });
+    });
+
+    it('does not touch the database for an empty id', async () => {
+        const provider = fakeProvider({});
+        expect(await LoadConversationScope('', USER, provider)).toEqual({ UserID: null, ExternalID: null, Readable: false });
+        expect(provider.GetEntityObject).not.toHaveBeenCalled();
+    });
+});
+
+describe('AuthorizeConversationTurn (a text agent turn addressed by a message in the conversation, MJ#6032)', () => {
+    const ANON = 'AAAAAAAA-0000-4000-8000-00000000A0A0';
+    const visitor = (sid: string) => ({ ID: ANON, IsMagicLinkAnonymous: true, AnonymousVisitorID: sid, MagicLinkScope: { ResourceID: sid } }) as unknown as UserInfo;
+
+    it('allows a named principal without reading the conversation (its permissions already decided the turn)', async () => {
+        const provider = fakeProvider({});
+        expect(await AuthorizeConversationTurn(CONVERSATION_ID, { ID: OWNER } as UserInfo, provider)).toEqual({ Allowed: true });
+        expect(provider.GetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('allows the anonymous visitor whose scope id the conversation carries', async () => {
+        const provider = fakeProvider({ conversation: { UserID: ANON, ExternalID: 'sid-1' } });
+        expect(await AuthorizeConversationTurn(CONVERSATION_ID, visitor('sid-1'), provider)).toEqual({ Allowed: true });
+    });
+
+    it('refuses a second anonymous visitor — same shared user, different scope id (the UI-guest-role leak)', async () => {
+        const provider = fakeProvider({ conversation: { UserID: ANON, ExternalID: 'sid-1' } });
+        expect(await AuthorizeConversationTurn(CONVERSATION_ID, visitor('sid-2'), provider)).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+    });
+
+    it('refuses an anonymous visitor when the conversation cannot be read or carries no scope id', async () => {
+        expect(await AuthorizeConversationTurn(CONVERSATION_ID, visitor('sid-1'), fakeProvider({ conversation: null }))).toEqual({ Allowed: false, Reason: 'not_owner' });
+        expect(await AuthorizeConversationTurn(CONVERSATION_ID, visitor('sid-1'), fakeProvider({ conversation: { UserID: ANON, ExternalID: null } }))).toEqual({ Allowed: false, Reason: 'scope_mismatch' });
+    });
+});
+
+describe('AuthorizeAnonymousRoomSessions (who of the anonymous visitors owns a LiveKit room\'s agent session, MJ#6044)', () => {
+    const ANON = 'AAAAAAAA-0000-4000-8000-00000000A0A0';
+    const visitor = (sid: string) => ({ ID: ANON, IsMagicLinkAnonymous: true, AnonymousVisitorID: sid, MagicLinkScope: { ResourceID: sid } }) as unknown as UserInfo;
+    const roomSession = { ID: SESSION_ID, UserID: ANON, ConversationID: CONVERSATION_ID };
+
+    it("admits the visitor whose scope id the session's conversation carries", async () => {
+        const provider = fakeProvider({ session: roomSession, conversation: { UserID: ANON, ExternalID: 'sid-1' } });
+        expect(await AuthorizeAnonymousRoomSessions([SESSION_ID], visitor('sid-1'), provider)).toBe(true);
+    });
+
+    it('refuses another visitor — same shared user, different scope id', async () => {
+        const provider = fakeProvider({ session: roomSession, conversation: { UserID: ANON, ExternalID: 'sid-1' } });
+        expect(await AuthorizeAnonymousRoomSessions([SESSION_ID], visitor('sid-2'), provider)).toBe(false);
+    });
+
+    it('refuses when the session cannot be read as the caller', async () => {
+        expect(await AuthorizeAnonymousRoomSessions([SESSION_ID], visitor('sid-1'), fakeProvider({ session: null }))).toBe(false);
+    });
+
+    it('refuses without reading anything when there is no session or no provider', async () => {
+        const provider = fakeProvider({});
+        expect(await AuthorizeAnonymousRoomSessions([], visitor('sid-1'), provider)).toBe(false);
+        expect(await AuthorizeAnonymousRoomSessions([SESSION_ID], visitor('sid-1'), undefined)).toBe(false);
+        expect(provider.GetEntityObject).not.toHaveBeenCalled();
+    });
+});
+
+
+describe('AuthorizeLoadedSession', () => {
+    const principals: Array<[string, UserInfo]> = [
+        ['named owner, no scope', { ID: OWNER } as UserInfo],
+        ['named owner, scope-1', { ID: OWNER, MagicLinkScope: { ResourceID: 'scope-1' } } as unknown as UserInfo],
+        ['named owner, scope-2', { ID: OWNER, MagicLinkScope: { ResourceID: 'scope-2' } } as unknown as UserInfo],
+        ['anonymous, scope-1', { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-1', MagicLinkScope: { ResourceID: 'scope-1' } } as unknown as UserInfo],
+        ['anonymous, scope-2', { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-2', MagicLinkScope: { ResourceID: 'scope-2' } } as unknown as UserInfo],
+        ['anonymous, visitor id only', { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-1' } as unknown as UserInfo],
+        ['anonymous, no scope', { ID: OWNER, IsMagicLinkAnonymous: true } as unknown as UserInfo],
+        ['named non-owner', { ID: OTHER } as UserInfo],
+    ];
+    const conversations: Array<[string, { conversationId: string | null; rows: Parameters<typeof fakeProvider>[0] }]> = [
+        ['no conversation', { conversationId: null, rows: {} }],
+        ['missing or refused', { conversationId: CONVERSATION_ID, rows: { conversation: null } }],
+        ['read fails', { conversationId: CONVERSATION_ID, rows: { conversation: {}, conversationThrows: true } }],
+        ['unstamped', { conversationId: CONVERSATION_ID, rows: { conversation: { ExternalID: null } } }],
+        ['stamped scope-1', { conversationId: CONVERSATION_ID, rows: { conversation: { ExternalID: 'scope-1' } } }],
+        ['stamped scope-2', { conversationId: CONVERSATION_ID, rows: { conversation: { ExternalID: 'scope-2' } } }],
+    ];
+
+    for (const [principalName, principal] of principals) {
+        for (const [conversationName, { conversationId, rows }] of conversations) {
+            it(`decides as if it always read the conversation: ${principalName} × ${conversationName}`, async () => {
+                const session = { ID: SESSION_ID, UserID: OWNER, ConversationID: conversationId } as unknown as MJAIAgentSessionEntity;
+                const scope = await LoadConversationScope(conversationId, principal, fakeProvider(rows));
+                const alwaysRead = AuthorizeSessionAccess(
+                    { SessionUserID: session.UserID, ConversationExternalID: scope.ExternalID, ConversationReadable: scope.Readable },
+                    principal,
+                );
+                expect(await AuthorizeLoadedSession(session, principal, fakeProvider(rows))).toEqual(alwaysRead);
+            });
+        }
+    }
+
+    const sessionWithConversation = { ID: SESSION_ID, UserID: OWNER, ConversationID: CONVERSATION_ID } as unknown as MJAIAgentSessionEntity;
+    const conversationReads = (provider: IMetadataProvider) =>
+        vi.mocked(provider.GetEntityObject).mock.calls.filter(([name]) => name === 'MJ: Conversations').length;
+
+    it('does not read the conversation for a named owner without a scope, the usual signed-in caller', async () => {
+        const provider = fakeProvider({ conversation: { ExternalID: 'scope-1' } });
+        expect(await AuthorizeLoadedSession(sessionWithConversation, USER, provider)).toEqual({ Allowed: true });
+        expect(conversationReads(provider)).toBe(0);
+    });
+
+    it('does not read the conversation for a caller who does not own the session', async () => {
+        const provider = fakeProvider({ conversation: { ExternalID: 'scope-1' } });
+        expect(await AuthorizeLoadedSession(sessionWithConversation, { ID: OTHER } as UserInfo, provider)).toEqual({ Allowed: false, Reason: 'not_owner' });
+        expect(conversationReads(provider)).toBe(0);
+    });
+
+    it('reads the conversation once for a caller with a scope identity', async () => {
+        const provider = fakeProvider({ conversation: { ExternalID: 'scope-1' } });
+        const guest = { ID: OWNER, IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-1', MagicLinkScope: { ResourceID: 'scope-1' } } as unknown as UserInfo;
+        expect(await AuthorizeLoadedSession(sessionWithConversation, guest, provider)).toEqual({ Allowed: true });
+        expect(conversationReads(provider)).toBe(1);
     });
 });

package/src/__tests__/realtimeSessions/sessionConfigStamps.test.ts

@@ -117,7 +117,7 @@ describe('LoadInheritedVerifiedIdentity', () => {
 
     it('refuses another anonymous guest (same Anonymous user, different scope) and accepts the same guest', async () => {
         const prov = provider({ externalId: 'scope-A' });
-        const guest = (scope: string) => user({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: scope } });
+        const guest = (scope: string) => user({ IsMagicLinkAnonymous: true, AnonymousVisitorID: scope, MagicLinkScope: { ResourceID: scope } });
         expect(await LoadInheritedVerifiedIdentity(PRIOR, guest('scope-B'), prov)).toBeUndefined();
         expect(await LoadInheritedVerifiedIdentity(PRIOR, guest('scope-A'), prov)).toEqual(VERIFIED);
     });

package/src/__tests__/realtimeSessions/verificationWorkflow.test.ts

@@ -96,6 +96,7 @@ class FakePorts implements VerificationPorts {
             AgentSessionID: SESSION_ID,
             OwnerUserID: OWNER,
             ConversationExternalID: null,
+            ConversationReadable: false,
             Status: 'Active',
             ConfigRaw: JSON.stringify({ targetAgentID: 'target-1' }),
             StartedAtMs: T0,
@@ -219,11 +220,17 @@ describe('RealtimeSessionVerificationWorkflow', () => {
         it('refuses another anonymous guest sharing the Anonymous user (scope mismatch) and a scope-less anonymous caller', async () => {
             ports.AddSession({ ConversationExternalID: 'scope-A' });
             expect(
-                await workflow.RequestVerification(REQUEST, principal({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'scope-B' } })),
+                await workflow.RequestVerification(
+                    REQUEST,
+                    principal({ IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-B', MagicLinkScope: { ResourceID: 'scope-B' } }),
+                ),
             ).toMatchObject({ ErrorCode: 'session_not_found' });
             expect(await workflow.RequestVerification(REQUEST, principal({ IsMagicLinkAnonymous: true }))).toMatchObject({ ErrorCode: 'session_not_found' });
             expect(
-                await workflow.RequestVerification(REQUEST, principal({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'scope-A' } })),
+                await workflow.RequestVerification(
+                    REQUEST,
+                    principal({ IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-A', MagicLinkScope: { ResourceID: 'scope-A' } }),
+                ),
             ).toMatchObject({ Success: true });
         });
 
@@ -232,6 +239,17 @@ describe('RealtimeSessionVerificationWorkflow', () => {
             expect(await workflow.RequestVerification(REQUEST, principal())).toMatchObject({ ErrorCode: 'session_closed' });
         });
 
+        it("lets a named owner holding a link scope use an unstamped conversation only when it can read that conversation", async () => {
+            // A conversation started outside any link carries no ExternalID. The owner's own row-level security
+            // decides: readable is allowed, unreadable is refused like a missing session.
+            const linkHolder = principal({ MagicLinkScope: { ResourceID: 'invite-scope-1' } });
+            ports.AddSession({ ConversationExternalID: null, ConversationReadable: false });
+            expect(await workflow.RequestVerification(REQUEST, linkHolder)).toMatchObject({ ErrorCode: 'session_not_found' });
+
+            ports.AddSession({ ConversationExternalID: null, ConversationReadable: true });
+            expect(await workflow.RequestVerification(REQUEST, linkHolder)).toMatchObject({ Success: true });
+        });
+
         it('treats an already-verified session as success without sending anything', async () => {
             await workflow.RequestVerification(REQUEST, principal());
             const { code } = secretsFrom(ports);
@@ -362,7 +380,7 @@ describe('RealtimeSessionVerificationWorkflow', () => {
 
         it('routes the event with the session scope so an anonymous guest\'s event reaches only that guest', async () => {
             ports.AddSession({ ConversationExternalID: 'scope-A' });
-            const guest = principal({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'scope-A' } });
+            const guest = principal({ IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-A', MagicLinkScope: { ResourceID: 'scope-A' } });
             await workflow.RequestVerification(REQUEST, guest);
             await workflow.SubmitCode({ AgentSessionID: SESSION_ID, Code: secretsFrom(ports).code }, guest);
             expect(ports.Published[0].routing.ScopeKey).toBe('scope-A');
@@ -445,7 +463,10 @@ describe('RealtimeSessionVerificationWorkflow', () => {
             expect(await workflow.SubmitCode({ AgentSessionID: SESSION_ID, Code: code }, principal({ ID: STRANGER }))).toMatchObject({ ErrorCode: 'session_not_found' });
             ports.AddSession({ ConversationExternalID: 'scope-A', ConfigRaw: ports.Sessions.get(SESSION_ID.toLowerCase())?.ConfigRaw ?? null });
             expect(
-                await workflow.SubmitCode({ AgentSessionID: SESSION_ID, Code: code }, principal({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'scope-B' } })),
+                await workflow.SubmitCode(
+                    { AgentSessionID: SESSION_ID, Code: code },
+                    principal({ IsMagicLinkAnonymous: true, AnonymousVisitorID: 'scope-B', MagicLinkScope: { ResourceID: 'scope-B' } }),
+                ),
             ).toMatchObject({ ErrorCode: 'session_not_found' });
             expect(ports.Published).toHaveLength(0);
         });