@memberjunction/server 6.2.0-edge.4 → 6.2.0-edge.6

package/src/__tests__/ActionResolver.fieldSecurity.test.ts

@@ -0,0 +1,237 @@
+// type-graphql decorators call `Reflect.getMetadata`; the polyfill must load before the resolver.
+import 'reflect-metadata';
+
+/**
+ * Field-level security and identity on `RunEntityAction`.
+ *
+ * - **Identity.** The record an entity action runs on is loaded for the CALLER. Loaded with no
+ *   user, it fell back to the provider's current user (the system user on a server), which is
+ *   full width and ignores the caller's row-level security as well.
+ * - **Output.** `ResultData` echoes the run's parameters back to the caller. The record bound as
+ *   `'Entity Object Data'` (a plain copy of its field values) and any entity object among the
+ *   parameters are projected for the caller; values of unknown shape are left alone.
+ *
+ * `RunAction` output gets the same backstop: entity objects are sent as their values projected for
+ * the caller, and plain objects shaped like a row of a field-secured entity lose the caller's
+ * denied keys.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, Subscription: noopDecorator,
+        ObjectType: noopDecorator, InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator,
+        Args: noopDecorator, Ctx: noopDecorator, PubSub: noopDecorator, Root: noopDecorator,
+        Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+        createUnionType: () => class {},
+        AuthorizationError: class AuthorizationError extends Error {},
+        Float: class {}, Int: class {}, ID: class {},
+    };
+});
+
+const hoisted = vi.hoisted(() => ({
+    runEntityAction: vi.fn(),
+    runAction: vi.fn(),
+    entityActions: [] as unknown[],
+    actionParams: [] as unknown[],
+}));
+
+vi.mock('@memberjunction/actions', () => ({
+    ActionEngineServer: {
+        Instance: {
+            get ActionParams() { return hoisted.actionParams; },
+            Actions: [{ ID: 'AC000000-0000-4000-8000-000000000001', Name: 'Return Rows' }],
+            Config: vi.fn(async () => undefined),
+            RunAction: hoisted.runAction,
+        },
+    },
+    EntityActionEngineServer: {
+        Instance: {
+            Config: vi.fn(async () => undefined),
+            get EntityActions() { return hoisted.entityActions; },
+            RunEntityAction: hoisted.runEntityAction,
+        },
+    },
+}));
+
+import { BaseEntity, EntityInfo, UserInfo } from '@memberjunction/core';
+import { ActionResolver, type EntityActionInput, type RunActionInput } from '../resolvers/ActionResolver.js';
+import type { AppContext } from '../types.js';
+import { EMPLOYEES_ENTITY_ID, EmployeeEntity, FullWidthEmployeeRow, HRUser, INTERN_ROLE_ID, Intern, SECRET_SALARY } from './fieldSecurityFixtures.js';
+
+const ENTITY_ACTION_ID = 'EA000000-0000-4000-8000-000000000001';
+const RECORD_PARAM_ID = 'AP000000-0000-4000-8000-000000000001';
+
+class EmployeeObject extends BaseEntity {}
+
+/** An entity object holding every column: what a load with no user produces on a server. */
+async function fullWidthEntityObject(entityInfo: EntityInfo): Promise<BaseEntity> {
+    const entity = new EmployeeObject(entityInfo);
+    await entity.LoadFromData(FullWidthEmployeeRow());
+    return entity;
+}
+
+function context(entityInfo: EntityInfo, getEntityObject: ReturnType<typeof vi.fn>): AppContext {
+    const provider = { Entities: [entityInfo], EntityByID: () => undefined, GetEntityObject: getEntityObject };
+    return {
+        providers: [{ type: 'Read-Only', provider }],
+        userPayload: { userRecord: Intern(), email: 'intern-1@test.com' },
+    } as unknown as AppContext;
+}
+
+const input = (): EntityActionInput => ({
+    EntityActionID: ENTITY_ACTION_ID,
+    InvocationType: 'SingleRecord',
+    EntityName: 'Employees',
+    PrimaryKey: { KeyValuePairs: [{ Key: 'ID', Value: 'emp-1' }] },
+} as unknown as EntityActionInput);
+
+let entityInfo: EntityInfo;
+let getEntityObject: ReturnType<typeof vi.fn>;
+
+beforeEach(async () => {
+    vi.clearAllMocks();
+    entityInfo = EmployeeEntity();
+    getEntityObject = vi.fn(async () => ({ InnerLoad: vi.fn(async () => true) }));
+    hoisted.entityActions.length = 0;
+    hoisted.entityActions.push({
+        ID: ENTITY_ACTION_ID,
+        EntityID: EMPLOYEES_ENTITY_ID,
+        Params: [{ ActionParamID: RECORD_PARAM_ID, ValueType: 'Entity Object Data' }],
+    });
+    hoisted.actionParams.length = 0;
+    hoisted.actionParams.push({ ID: RECORD_PARAM_ID, Name: 'Record' });
+    hoisted.runEntityAction.mockResolvedValue({ Success: true, Message: 'ok', Params: [] });
+});
+
+describe('RunEntityAction: the record is loaded for the caller', () => {
+    it('REGRESSION: loads the bound record with the caller as its user', async () => {
+        await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+        expect(getEntityObject).toHaveBeenCalledWith('Employees', expect.objectContaining({ ID: 'intern-1' }));
+    });
+
+    it('refuses to run on a record the caller cannot load, with no hint whether it exists', async () => {
+        getEntityObject.mockResolvedValue({ InnerLoad: vi.fn(async () => false) });
+        const result = await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+        expect(result.Success).toBe(false);
+        expect(result.Message).toContain('Record not found or access denied');
+        expect(hoisted.runEntityAction).not.toHaveBeenCalled();
+    });
+});
+
+describe('RunEntityAction: echoed parameters are projected for the caller', () => {
+    it("REGRESSION: the 'Entity Object Data' parameter never carries a denied value", async () => {
+        const params = [{ Name: 'Record', Value: FullWidthEmployeeRow(), Type: 'Input' }];
+        hoisted.runEntityAction.mockResolvedValue({ Success: true, Message: 'ok', Params: params, RunParams: { Params: params } });
+
+        const result = await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+
+        expect(result.Success).toBe(true);
+        expect(result.ResultData).not.toContain(String(SECRET_SALARY));
+        expect(JSON.parse(result.ResultData!).Params[0].Value).toEqual({ ID: 'emp-1', Name: 'Ada', Notes: 'n' });
+    });
+
+    it('REGRESSION: an entity object among the parameters is sent as its projected field values', async () => {
+        const params = [{ Name: 'Entity', Value: await fullWidthEntityObject(entityInfo), Type: 'Input' }];
+        hoisted.runEntityAction.mockResolvedValue({ Success: true, Message: 'ok', Params: params, RunParams: { Params: params } });
+
+        const result = await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+
+        expect(result.ResultData).not.toContain(String(SECRET_SALARY));
+        expect(JSON.parse(result.ResultData!).Params[0].Value).toMatchObject({ ID: 'emp-1', Name: 'Ada' });
+    });
+
+    it('REGRESSION: an entity object of an entity the caller cannot read is sent as null, not as its other fields', async () => {
+        const unreadable = EmployeeEntity();
+        unreadable.Permissions.splice(0, unreadable.Permissions.length, ...unreadable.Permissions.filter(p => p.RoleID !== INTERN_ROLE_ID));
+        const object = await fullWidthEntityObject(unreadable);
+        const params = [
+            { Name: 'One', Value: object, Type: 'Output' },
+            { Name: 'Many', Value: [object], Type: 'Output' },
+        ];
+        hoisted.runEntityAction.mockResolvedValue({ Success: true, Message: 'ok', Params: params, RunParams: { Params: params } });
+
+        const result = await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+
+        const sent = JSON.parse(result.ResultData!) as { Params: { Value: unknown }[]; RunParams: { Params: { Value: unknown }[] } };
+        expect(sent.Params[0].Value).toBeNull();
+        expect(sent.Params[1].Value).toEqual([null]);
+        expect(sent.RunParams.Params[0].Value).toBeNull();
+        expect(result.ResultData).not.toContain('Ada');
+    });
+
+    it('leaves a parameter of unknown shape alone', async () => {
+        const params = [{ Name: 'Other', Value: { Salary: 1 }, Type: 'Output' }];
+        hoisted.runEntityAction.mockResolvedValue({ Success: true, Message: 'ok', Params: params });
+
+        const result = await new ActionResolver().RunEntityAction(input(), context(entityInfo, getEntityObject));
+
+        expect(JSON.parse(result.ResultData!).Params[0].Value).toEqual({ Salary: 1 });
+    });
+});
+
+// ─── RunAction: general action output ────────────────────────────────────────
+
+const ACTION_ID = 'AC000000-0000-4000-8000-000000000001';
+
+/** An Owner may run any action, so these tests reach the output without the authorization lookup. */
+function owner(user: UserInfo): UserInfo {
+    user.Type = 'Owner';
+    return user;
+}
+
+function runActionContext(entity: EntityInfo, user: UserInfo): AppContext {
+    const provider = { Entities: [entity], EntityByID: () => undefined };
+    return {
+        providers: [{ type: 'Read-Write', provider }],
+        userPayload: { userRecord: user, email: user.Email },
+    } as unknown as AppContext;
+}
+
+async function runActionReturning(value: unknown, user: UserInfo): Promise<unknown> {
+    hoisted.runAction.mockResolvedValue({ Success: true, Message: 'ok', Params: [{ Name: 'Rows', Type: 'Output', Value: value }] });
+    const result = await new ActionResolver().RunAction({ ActionID: ACTION_ID } as RunActionInput, runActionContext(entityInfo, user));
+    expect(result.Success).toBe(true);
+    return JSON.parse(result.ResultData!)[0].Value;
+}
+
+describe('RunAction: output parameters are projected for the caller', () => {
+    it('REGRESSION: a system-loaded entity object is sent as its projected values to a restricted caller', async () => {
+        const value: BaseEntity = await fullWidthEntityObject(entityInfo);
+        expect(await runActionReturning(value, owner(Intern()))).toEqual({ ID: 'emp-1', Name: 'Ada', Notes: 'n' });
+    });
+
+    it('REGRESSION: the same entity object keeps the field for a caller allowed to read it', async () => {
+        const value: BaseEntity = await fullWidthEntityObject(entityInfo);
+        expect(await runActionReturning(value, owner(HRUser()))).toMatchObject({ ID: 'emp-1', Salary: SECRET_SALARY });
+    });
+
+    it('REGRESSION: a GetAll()-shaped row of a field-secured entity loses the denied field', async () => {
+        const value = await runActionReturning([FullWidthEmployeeRow()], owner(Intern()));
+        expect(value).toEqual([{ ID: 'emp-1', Name: 'Ada', Notes: 'n' }]);
+        expect(JSON.stringify(value)).not.toContain(String(SECRET_SALARY));
+    });
+
+    it('leaves a non-entity-shaped object untouched', async () => {
+        expect(await runActionReturning({ Salary: 1, Total: 2 }, owner(Intern()))).toEqual({ Salary: 1, Total: 2 });
+    });
+
+    it("REGRESSION: an entity object of an entity the caller cannot read is not exposed", async () => {
+        const unreadable = EmployeeEntity();
+        unreadable.Permissions.splice(0, unreadable.Permissions.length, ...unreadable.Permissions.filter(p => p.RoleID !== INTERN_ROLE_ID));
+        const object = await fullWidthEntityObject(unreadable);
+        hoisted.runAction.mockResolvedValue({ Success: true, Message: 'ok', Params: [
+            { Name: 'One', Type: 'Output', Value: object },
+            { Name: 'Many', Type: 'Output', Value: [object] },
+        ] });
+        const result = await new ActionResolver().RunAction({ ActionID: ACTION_ID } as RunActionInput, runActionContext(unreadable, owner(Intern())));
+        // Exactly the shape this output had before entity objects were projected: the single object's
+        // Value dropped, the array's item nulled (and, as ever, the list serialized index-keyed).
+        expect(JSON.parse(result.ResultData!)).toEqual({ 0: { Name: 'One', Type: 'Output' }, 1: { Name: 'Many', Type: 'Output', Value: [null] } });
+    });
+
+    it('sends the full row to a caller denied nothing', async () => {
+        expect(await runActionReturning([FullWidthEmployeeRow()], owner(HRUser()))).toEqual([FullWidthEmployeeRow()]);
+    });
+});

package/src/__tests__/AdhocQueryResolver.dialect.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Regression suite for the ad-hoc read-only execution path being SQL-Server-shaped.
+ *
+ * The bug — `ExecuteAdhocQuery` opened with
+ * `GetReadOnlyDataSource(context.dataSources, …)`, which looks for an **mssql
+ * `ConnectionPool`**. A PostgreSQL provider never populates `context.dataSources`
+ * with one, so every ad-hoc query on PostgreSQL returned
+ * "No read-only data source available for ad-hoc query execution".
+ *
+ * `next` fixed the execution path (R31): the resolver now hands the SQL to the
+ * read-only PROVIDER's `RunQuery`, and renders it for that provider's platform.
+ * This suite pins the dialect half of that contract — the platform comes from the
+ * provider the SQL runs on, never from a literal, and nothing reaches for mssql —
+ * and drives the resolver against a PostgreSQL provider with no mssql pool at all.
+ * Paging, the timeout clamp and the read authorizer have their own suites.
+ */
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// `RunQueryResultType` is a type-graphql object type whose fields rely on
+// `emitDecoratorMetadata`. esbuild (what vitest transforms with) cannot emit it,
+// so importing QueryResolver for real fails at decoration time. The resolver only
+// uses the class as the @Query return marker, so a bare stand-in is enough and
+// keeps the REAL AdhocQueryResolver under test.
+vi.mock('../resolvers/QueryResolver.js', () => ({
+    RunQueryResultType: class RunQueryResultType {},
+}));
+
+// The server config is read from mj.config at import; only the timeout cap is used here.
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+import { AdhocQueryResolver } from '../resolvers/AdhocQueryResolver.js';
+import type { AppContext } from '../types.js';
+
+const ADHOC_RESOLVER_PATH = resolve(__dirname, '../resolvers/AdhocQueryResolver.ts');
+
+function readResolverSource(): string {
+    return readFileSync(ADHOC_RESOLVER_PATH, 'utf8');
+}
+
+type RunQueryCall = { SQL: string; MaxRows?: number; StartRow?: number };
+
+function postgresContext(calls: RunQueryCall[], rows: Record<string, unknown>[]): AppContext {
+    const provider = {
+        PlatformKey: 'postgresql',
+        RunQuery: async (params: RunQueryCall) => {
+            calls.push(params);
+            return { Success: true, Results: rows, RowCount: rows.length, TotalRowCount: rows.length };
+        },
+    };
+    return {
+        // Deliberately EMPTY: a PostgreSQL tenant has no mssql ConnectionPool here.
+        // If the resolver still reaches for one, these tests fail.
+        dataSources: [],
+        providers: [{ type: 'Read-Only', provider }],
+        userPayload: { userRecord: { ID: 'u-1', Name: 'Tester' } },
+    } as unknown as AppContext;
+}
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('AdhocQueryResolver dialect source-shape contract', () => {
+    it('must NOT gate execution on a SQL-Server-only read-only data source', () => {
+        expect(readResolverSource()).not.toContain('GetReadOnlyDataSource');
+    });
+
+    it('must NOT depend on the mssql driver', () => {
+        const src = readResolverSource();
+        expect(src).not.toMatch(/^import .* from 'mssql';$/m);
+        expect(src).not.toContain('new sql.Request(');
+        expect(src).not.toContain('sql.ConnectionPool');
+    });
+
+    it('renders for the platform of the read-only provider the SQL runs on, not a literal', () => {
+        const src = readResolverSource();
+        expect(src).toContain('GetReadOnlyProvider(context.providers');
+        expect(src).toContain('Platform: provider.PlatformKey');
+        expect(src).not.toMatch(/platform\s*(:\s*DatabasePlatform\s*)?=\s*'sqlserver'/);
+        expect(src).not.toMatch(/Platform:\s*'sqlserver'/);
+    });
+});
+
+describe('ExecuteAdhocQuery on a PostgreSQL tenant', () => {
+    it('runs on the read-only provider instead of refusing for want of an mssql pool', async () => {
+        const resolver = new AdhocQueryResolver();
+        const authorize = vi.spyOn(resolver, 'AuthorizeRenderedSQL').mockReturnValue(null);
+        const calls: RunQueryCall[] = [];
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            postgresContext(calls, [{ ID: '1' }, { ID: '2' }]),
+        );
+
+        expect(result.ErrorMessage).not.toContain('No read-only data source');
+        expect(result.Success).toBe(true);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].SQL).toBe('SELECT ID FROM __mj.vwUsers');
+        expect(JSON.parse(result.Results)).toEqual([{ ID: '1' }, { ID: '2' }]);
+        // The SQL is authorized (and so rendered) against the same PostgreSQL provider it runs on.
+        expect((authorize.mock.calls[0][1] as { PlatformKey: string }).PlatformKey).toBe('postgresql');
+    });
+});
+
+describe('ExecuteAdhocQuery refusal path', () => {
+    it('still refuses when there is no read-only provider at all', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            { dataSources: [], providers: [], userPayload: { userRecord: { ID: 'u-1' } } } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available for ad-hoc query execution');
+    });
+
+    it('does NOT fall back to a read-write provider', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            {
+                dataSources: [],
+                providers: [{ type: 'Read-Write', provider: { PlatformKey: 'postgresql', RunQuery: async () => ({ Success: true, Results: [] }) } }],
+                userPayload: { userRecord: { ID: 'u-1' } },
+            } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available');
+    });
+});

package/src/__tests__/AgentRunStatusPublisher.test.ts

@@ -29,6 +29,7 @@ vi.mock('@memberjunction/graphql-dataprovider', () => ({
 import type { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { ConversationStreaming, type IConversationsRuntimeContext } from '@memberjunction/conversations-runtime';
 import { AgentRunStatusPublisher } from '../resolvers/AgentRunStatusPublisher.js';
+import { StatusUpdatesFilter, type PushStatusNotificationPayload } from '../generic/PushStatusResolver.js';
 import type { UserPayload } from '../types.js';
 
 const run = {
@@ -56,6 +57,31 @@ function envelopes(publish: ReturnType<typeof vi.fn>): Array<Record<string, unkn
 }
 
 describe('AgentRunStatusPublisher', () => {
+    it('stamps the reply row on every message when it has one, so a reconnecting client can find its row', () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub = { publish } as unknown as PubSubEngine;
+        const userPayload = { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload;
+        const made = new AgentRunStatusPublisher(pubSub, userPayload, 'session-1', 'reply-7');
+        const runWithoutDetail = { ...run, ConversationDetailID: undefined, GetAll: () => ({ ID: 'run-1' }) };
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: runWithoutDetail } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+        made.PublishFinal({ success: true, agentRun: runWithoutDetail } as unknown as ExecuteAgentResult);
+
+        const details = envelopes(publish).map((row) => (row.data as { conversationDetailId?: string }).conversationDetailId);
+        expect(details).toEqual(['reply-7', 'reply-7', 'reply-7', 'reply-7']);
+    });
+
+    it('leaves progress and streaming messages without a reply row when it has none, as before', () => {
+        const { publish, made } = publisher();
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: run } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+
+        const sent = envelopes(publish).map((row) => row.data as Record<string, unknown>);
+        expect(sent.every((data) => !('conversationDetailId' in data))).toBe(true);
+    });
+
     it('publishes the resolver sequence: a significant step, streamed text, the partial result, then the completion', () => {
         const { publish, made } = publisher();
 
@@ -173,3 +199,26 @@ describe('AgentRunStatusPublisher', () => {
         expect(streaming.GetRecentCompletion('detail-1')?.agentRunId).toBe('run-1');
     });
 });
+
+describe('AgentRunStatusPublisher — a widget guest elevated to the system user (#4931)', () => {
+    const GUEST = { ID: 'anonymous-user', IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-a', MagicLinkScope: { ResourceID: 'sid-a' } };
+    const SYSTEM = { ID: 'system-user' };
+
+    it("stamps the guest (ElevatedFrom), not the elevated user, so the guest's own socket receives the run's events", () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const elevated = { sessionId: 'session-1', userRecord: SYSTEM, isSystemUser: true, ElevatedFrom: GUEST } as unknown as UserPayload;
+        const made = new AgentRunStatusPublisher({ publish } as unknown as PubSubEngine, elevated, 'session-1');
+
+        made.PublishFinal({ success: true, agentRun: run, payload: { text: 'Hello' } } as ExecuteAgentResult, 'detail-1', '{"text":"Hello"}');
+        made.PublishFailure('detail-1', 'boom');
+
+        const owners = publish.mock.calls.map((call) => (call[1] as { ownerUserId: string }).ownerUserId);
+        expect(owners.length).toBeGreaterThan(0);
+        // An anonymous visitor's owner key carries its scope identity, so another visitor cannot receive these events.
+        expect(owners.every((owner) => owner === 'anonymous-user|sid-a')).toBe(true);
+        const guestConnection = { userPayload: { sessionId: 'session-1', userRecord: GUEST } as unknown as UserPayload };
+        for (const call of publish.mock.calls) {
+            expect(StatusUpdatesFilter({ payload: call[1] as PushStatusNotificationPayload, args: { sessionId: 'session-1' }, context: guestConnection })).toBe(true);
+        }
+    });
+});

package/src/__tests__/AgentSessionResolver.ownership.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { AppContext } from '../types.js';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator,
+        Mutation: noopDecorator,
+        Arg: noopDecorator,
+        Ctx: noopDecorator,
+        ObjectType: noopDecorator,
+        Field: noopDecorator,
+    };
+});
+
+vi.mock('../generic/ResolverBase.js', () => ({
+    ResolverBase: class {
+        protected GetUserFromPayload(payload?: { userRecord?: UserInfo }): UserInfo | undefined {
+            return payload?.userRecord;
+        }
+    },
+}));
+
+const closeSessionMock = vi.fn(async () => true);
+const heartbeatMock = vi.fn(async () => true);
+
+vi.mock('../agentSessions/index.js', () => ({
+    SessionManager: class {
+        CloseSession = closeSessionMock;
+        Heartbeat = heartbeatMock;
+    },
+    SessionAuthorizationError: class extends Error {},
+}));
+
+import { AgentSessionResolver } from '../resolvers/AgentSessionResolver.js';
+
+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 = (visitorId: string) =>
+    ({
+        ID: ANON,
+        IsMagicLinkAnonymous: true,
+        // An unscoped multi-use invite: redemptions are told apart by mj_sid (a resource scope would be shared).
+        AnonymousVisitorID: visitorId,
+    }) as unknown as UserInfo;
+
+function makeProvider(sessionFound = true, externalId = 'visitor-1'): IMetadataProvider {
+    return {
+        GetEntityObject: vi.fn(async (entityName: string) =>
+            entityName === 'MJ: AI Agent Sessions'
+                ? { UserID: ANON, ConversationID: CONVERSATION, Load: vi.fn(async () => sessionFound) }
+                : { ExternalID: externalId, Load: vi.fn(async () => true) },
+        ),
+    } as unknown as IMetadataProvider;
+}
+
+function makeCtx(user: UserInfo, provider: IMetadataProvider): AppContext {
+    return {
+        userPayload: { email: 'anonymous@magic-link.local', sessionId: 's', userRecord: user },
+        providers: [{ provider, type: 'Read-Write' }],
+    } as unknown as AppContext;
+}
+
+describe('AgentSessionResolver anonymous visitor ownership', () => {
+    beforeEach(() => {
+        closeSessionMock.mockClear();
+        heartbeatMock.mockClear();
+    });
+
+    it('CloseAgentSession allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+    });
+
+    it('AgentSessionHeartbeat allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+    });
+
+    it('throws the expected not-found message when the session does not exist', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(false);
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+    });
+});
+
+describe('CloseAgentSession close reason (MJ#6013)', () => {
+    beforeEach(() => closeSessionMock.mockClear());
+
+    it('passes a client-reportable reason through, so a start that failed is recorded as an Error', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Error')).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Error');
+    });
+
+    it('defaults to Explicit when the client sends no reason (older clients)', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Explicit');
+    });
+
+    it('refuses a reason only the server may stamp', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Janitor')).rejects.toThrow(/close reason/i);
+        expect(closeSessionMock).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/CustomColumnPromoterOnePass.test.ts

@@ -14,10 +14,19 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 
 const runPipelineBatchMock = vi.fn();
+/**
+ * MJ-APPLY-6 — the BARE, non-retrying entry point. Bound separately so a regression back to it is
+ * an assertion failure rather than an invisible loss of the retry. Promotion runs unattended
+ * mid-sync; a transient pipeline step failing there drops the whole promotion silently.
+ */
+const runPipelineBatchBareMock = vi.fn();
 vi.mock('@memberjunction/schema-engine', () => ({
     RuntimeSchemaManager: {
         get Instance() {
-            return { RunPipelineBatch: runPipelineBatchMock };
+            return {
+                RunPipelineBatch: runPipelineBatchBareMock,
+                RunPipelineBatchWithRetry: runPipelineBatchMock,
+            };
         },
     },
 }));
@@ -104,6 +113,7 @@ function stubPromoter(
 
 beforeEach(() => {
     runPipelineBatchMock.mockReset();
+    runPipelineBatchBareMock.mockReset();
 });
 
 describe('PromoteForSync — one batched RSU pass', () => {
@@ -122,6 +132,10 @@ describe('PromoteForSync — one batched RSU pass', () => {
         const result = await promoter.PromoteForSync('ci-1', ['A', 'B', 'C']);
 
         expect(runPipelineBatchMock).toHaveBeenCalledTimes(1);
+        // MJ-APPLY-6 — the ONE pass has to be the RETRYING one. Promotion is unattended: a
+        // transient ExecuteMigration/RunCodeGen/Compile/Restart failure with no replay drops every
+        // accepted column back into overflow and nothing reruns it.
+        expect(runPipelineBatchBareMock).not.toHaveBeenCalled();
         expect(runPipelineBatchMock.mock.calls[0][0]).toHaveLength(3);
         expect(result.Promoted).toBe(true);
         expect(result.ColumnsAdded).toEqual([