@memberjunction/server 6.2.0-edge.1 → 6.2.0-edge.2

package/src/__tests__/DuplicateEntryCheckResolver.test.ts

@@ -0,0 +1,300 @@
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/** The slice of `APIKeyEngine.Authorize` that ResolverBase.CheckAPIKeyScopeAuthorization calls. */
+type AuthorizeFn = (
+  apiKeyHash: string,
+  application: string,
+  scopePath: string,
+  resource: string
+) => Promise<{ Allowed: boolean; Reason: string }>;
+
+const { mockAuthorize, mockLogError } = vi.hoisted(() => ({
+  mockAuthorize: vi.fn<AuthorizeFn>(),
+  mockLogError: vi.fn<(message: string) => void>(),
+}));
+
+// As in RunDecisionResolver.test.ts: vitest's esbuild transform does not apply
+// `emitDecoratorMetadata`, so the decorators are no-ops and the resolver runs as a plain class.
+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 {
+      constructor(message?: string) {
+        super(message);
+        this.name = 'AuthorizationError';
+      }
+    },
+    Float: class {}, Int: class {}, ID: class {},
+  };
+});
+
+// Only logging is replaced, so a test can tell a logged fault from a quiet answer.
+vi.mock('@memberjunction/core', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return { ...actual, LogError: mockLogError };
+});
+
+// Only the API-key engine is replaced; ResolverBase's scope check itself is the production code.
+vi.mock('@memberjunction/api-keys', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return { ...actual, GetAPIKeyEngine: () => ({ Authorize: mockAuthorize }) };
+});
+
+// The resolver's tests replace the detector through CreateEntryChecker, so the detector package
+// is never exercised here; it has its own specs.
+vi.mock('@memberjunction/ai-vector-dupe', () => ({ DuplicateRecordDetector: class {} }));
+
+import { EntityInfo, Metadata, UserInfo } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/generic-database-provider';
+import type { DuplicateEntryCheckResult } from '@memberjunction/ai-vector-dupe';
+import {
+  DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH,
+  DuplicateEntryCheckResolver,
+  type DuplicateEntryChecker,
+} from '../resolvers/DuplicateEntryCheckResolver.js';
+import type { UserPayload } from '../types.js';
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const USER = new UserInfo(null, {
+  ID: 'user-1',
+  Name: 'Entry Person',
+  Email: 'person@example.com',
+  UserRoles: [{ UserID: 'user-1', RoleID: 'role-ui' }],
+});
+const SYSTEM_USER = new UserInfo(null, { ID: 'user-system', Name: 'System', Email: 'system@example.com' });
+
+/** An entity the user's role may read. */
+const ACCOUNTS = new EntityInfo({
+  ID: 'entity-accounts',
+  Name: 'Accounts',
+  Status: 'Active',
+  Fields: [
+    { Name: 'ID', Type: 'uniqueidentifier', IsPrimaryKey: true },
+    { Name: 'Name', Type: 'nvarchar', IsNameField: true, AllowUpdateAPI: true },
+    { Name: 'City', Type: 'nvarchar', AllowUpdateAPI: true },
+    { Name: 'Owner', Type: 'nvarchar', AllowUpdateAPI: false },
+    { Name: '__mj_CreatedAt', Type: 'datetimeoffset', AllowUpdateAPI: false },
+  ],
+  EntityPermissions: [{ RoleID: 'role-ui', CanRead: true }],
+});
+
+/** An entity only another role may read. */
+const PAYROLL = new EntityInfo({
+  ID: 'entity-payroll',
+  Name: 'Payroll',
+  Status: 'Active',
+  Fields: [{ Name: 'ID', Type: 'uniqueidentifier', IsPrimaryKey: true }],
+  EntityPermissions: [{ RoleID: 'role-finance', CanRead: true }],
+});
+
+const CHECKED: DuplicateEntryCheckResult = {
+  Status: 'Checked',
+  Candidates: [{ RecordID: 'acct-7', DisplayName: 'Acme Corp', VectorScore: 0.93, Probability: 0.81 }],
+  ElapsedMs: 212,
+};
+
+/** A session authenticated by JWT: no API key, so no scope check. */
+const sessionPayload = (): UserPayload => ({ email: USER.Email, userRecord: USER, sessionId: 'session-1' });
+/** A session authenticated by an MJ API key: scope-checked. */
+const apiKeyPayload = (): UserPayload => ({ ...sessionPayload(), apiKeyId: 'key-1', apiKeyHash: 'hash-1' });
+
+/** The resolver with its detector replaced by a double. */
+class TestResolver extends DuplicateEntryCheckResolver {
+  public readonly Checker = { CheckRecordValues: vi.fn<DuplicateEntryChecker['CheckRecordValues']>() };
+
+  protected override CreateEntryChecker(): DuplicateEntryChecker {
+    return this.Checker;
+  }
+}
+
+let resolver: TestResolver;
+
+const check = (entityName: string, valuesJSON: string, payload: UserPayload = sessionPayload()) =>
+  resolver.RunEntryCheck(entityName, valuesJSON, payload, null);
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+  mockAuthorize.mockReset();
+  mockLogError.mockReset();
+  vi.spyOn(Metadata.prototype, 'EntityByName').mockImplementation((name: string) =>
+    [ACCOUNTS, PAYROLL].find(e => e.Name.toLowerCase() === name.trim().toLowerCase())
+  );
+  vi.spyOn(UserCache.prototype, 'GetSystemUser').mockReturnValue(SYSTEM_USER);
+  resolver = new TestResolver();
+  resolver.Checker.CheckRecordValues.mockResolvedValue(CHECKED);
+});
+
+// ─── Authorization ───────────────────────────────────────────────────────────
+
+/** The scope checks made, other than the full_access fast path, as [scope, resource]. */
+const scopeChecks = () => mockAuthorize.mock.calls.filter(call => call[2] !== 'full_access').map(call => [call[2], call[3]]);
+
+describe('CheckDuplicateEntry: authorization', () => {
+  it('answers NotAuthorized, without logging, for a user who cannot read the entity', async () => {
+    const result = await check('Payroll', '{"ID":"x"}');
+
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain('does not have read permissions on Payroll');
+    expect(result.Candidates).toEqual([]);
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+    expect(mockLogError).not.toHaveBeenCalled();
+  });
+
+  it('fails an unknown entity without running the check', async () => {
+    const result = await check('No Such Entity', '{}');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'Entity not found in metadata' });
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('applies the view:run API-key scope for the entity, and a denial is a status', async () => {
+    mockAuthorize.mockResolvedValue({ Allowed: false, Reason: 'scope not granted' });
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts']]);
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain("requires the 'view:run' scope");
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+    expect(mockLogError).not.toHaveBeenCalled();
+  });
+
+  it('also requires prompt:execute, so a read-only key cannot spend on model calls', async () => {
+    mockAuthorize.mockImplementation(async (_hash, _app, scopePath) =>
+      scopePath === 'view:run' ? { Allowed: true, Reason: '' } : { Allowed: false, Reason: 'scope not granted' }
+    );
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts'], ['prompt:execute', '*']]);
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain("requires the 'prompt:execute' scope");
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('runs the check for a key holding both scopes', async () => {
+    mockAuthorize.mockImplementation(async (_hash, _app, scopePath) =>
+      ({ Allowed: scopePath !== 'full_access', Reason: '' })
+    );
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts'], ['prompt:execute', '*']]);
+    expect(result.Status).toBe('Checked');
+  });
+});
+
+// ─── The values ──────────────────────────────────────────────────────────────
+
+describe('CheckDuplicateEntry: the values', () => {
+  it('returns an error status, not a throw, for values that are not JSON', async () => {
+    const result = await check('Accounts', '{ Name: ');
+
+    expect(result.Status).toBe('Failed');
+    expect(result.ErrorMessage).toMatch(/^valuesJSON is not valid JSON: /);
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('returns an error status for JSON that is not an object', async () => {
+    const result = await check('Accounts', '["Acme"]');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'valuesJSON must be the JSON of an object of field values' });
+  });
+
+  it('ignores the fields the entity does not have, and keys the rest by the real field name', async () => {
+    await check('Accounts', JSON.stringify({ name: 'Acme', City: 'Boston', Revenue: 5, NotAField: 'x' }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme', City: 'Boston' }, USER);
+  });
+
+  it('ignores primary keys, read-only fields and MJ system fields', async () => {
+    await check('Accounts', JSON.stringify({ ID: 'acct-7', Name: 'Acme', Owner: 'someone', __mj_CreatedAt: '2026-01-01' }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme' }, USER);
+  });
+
+  it('accepts strings, numbers, booleans and null', async () => {
+    await check('Accounts', JSON.stringify({ Name: 'Acme', City: null, Revenue: 5, Active: true }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme', City: null }, USER);
+  });
+
+  it.each([
+    ['an array', { Name: ['Acme', 'Corp'] }],
+    ['an object', { Name: { first: 'Acme' } }],
+  ])('refuses a value that is %s', async (_kind, values) => {
+    const result = await check('Accounts', JSON.stringify(values));
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: "valuesJSON field 'Name' must be a string, number, boolean or null" });
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('refuses a value of an unknown field that is not a scalar', async () => {
+    const result = await check('Accounts', JSON.stringify({ Name: 'Acme', Extra: [1, 2, 3] }));
+
+    expect(result.Status).toBe('Failed');
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('accepts valuesJSON up to DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH characters and refuses one more', async () => {
+    const padding = DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH - JSON.stringify({ Name: '' }).length;
+    const atLimit = JSON.stringify({ Name: 'x'.repeat(padding) });
+    const overLimit = JSON.stringify({ Name: 'x'.repeat(padding + 1) });
+    expect(atLimit).toHaveLength(DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH);
+
+    expect((await check('Accounts', atLimit)).Status).toBe('Checked');
+    const refused = await check('Accounts', overLimit);
+
+    expect(refused).toMatchObject({
+      Status: 'Failed',
+      ErrorMessage: `valuesJSON is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH + 1} characters; the limit is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH}`,
+    });
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps the limit to a few KB', () => {
+    expect(DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH).toBeLessThanOrEqual(32 * 1024);
+  });
+});
+
+// ─── The result ──────────────────────────────────────────────────────────────
+
+describe('CheckDuplicateEntry: the result', () => {
+  it('returns the detector result', async () => {
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toEqual({
+      Status: 'Checked',
+      ErrorMessage: undefined,
+      Candidates: [{ RecordID: 'acct-7', DisplayName: 'Acme Corp', VectorScore: 0.93, Probability: 0.81 }],
+      ElapsedMs: 212,
+    });
+  });
+
+  it('passes NotConfigured through', async () => {
+    resolver.Checker.CheckRecordValues.mockResolvedValue({ Status: 'NotConfigured', Candidates: [], ElapsedMs: 3 });
+
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toMatchObject({ Status: 'NotConfigured', Candidates: [] });
+  });
+
+  it('returns Failed, not a throw, when the check throws, and logs it', async () => {
+    resolver.Checker.CheckRecordValues.mockRejectedValue(new Error('vector index unreachable'));
+
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'vector index unreachable', Candidates: [] });
+    expect(mockLogError).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/RealtimeClientSessionResolver.test.ts

@@ -3,7 +3,7 @@
 // bring it in automatically — this line MUST precede any import that pulls in the resolver file.
 import 'reflect-metadata';
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 // --- Mock CanRun authorization (AIAgentPermissionHelper.HasPermission) plus the
 //     provider-scoped AIEngineBase whose cached metadata serves the resolver's pairing-row
@@ -210,9 +210,23 @@ interface FakeSession {
     NewRecord: () => void;
     Save: () => Promise<boolean>;
     Load: (id: string) => Promise<boolean>;
-    LatestResult?: { CompleteMessage?: string };
+    LatestResult?: { CompleteMessage?: string; Success?: boolean };
+    /** Only set on the fakes exercising `describeSaveFailure`'s "no failure detail recorded" branches. */
+    ResultHistory?: unknown[];
 }
 
+/**
+ * A `console.error` spy shared by the save-failure-log tests (#4791) below. Assigned with
+ * `vi.spyOn(console, 'error').mockImplementation(() => undefined)` inside each test that needs it
+ * — restored here so no test leaks a mocked `console.error` into the ones after it.
+ */
+let errSpy: ReturnType<typeof vi.spyOn> | undefined;
+
+afterEach(() => {
+    errSpy?.mockRestore();
+    errSpy = undefined;
+});
+
 function makeSessionEntity(overrides: Partial<FakeSession> = {}): FakeSession {
     return {
         ID: 'session-1',
@@ -848,6 +862,28 @@ describe('RealtimeClientSessionResolver.ExecuteRealtimeSessionTool', () => {
             resolver.ExecuteRealtimeSessionTool('session-1', 'call-1', 'x', '{}', makeCtx(), makePubSub()),
         ).rejects.toThrow(/no target agent configured/i);
     });
+
+    it('logs the session id and "no failure detail recorded" when updatePendingFeedbackRunID\'s save is refused silently (#4791)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const session = makeSessionEntity({
+            Config_: JSON.stringify({ targetAgentID: 'target-1' }),
+            Save: vi.fn(async () => false),
+            LatestResult: undefined,
+            ResultHistory: [],
+        });
+        currentProvider = makeProvider(() => session);
+        executeRelayedToolMock.mockResolvedValue({ ResultJson: '{"q":1}', Success: true, PausedRunID: 'paused-1' });
+        const resolver = makeResolver();
+
+        await resolver.ExecuteRealtimeSessionTool('session-1', 'call-1', 'invoke-target-agent', '{}', makeCtx(), makePubSub());
+
+        const loggedLines = errSpy.mock.calls.map((call) => String(call[0]));
+        const failureLine = loggedLines.find((line) => line.includes('updatePendingFeedbackRunID'));
+        expect(failureLine).toBeDefined();
+        expect(failureLine).toContain('session-1');
+        expect(failureLine).toContain('no failure detail recorded');
+        expect(failureLine).not.toContain('unknown error');
+    });
 });
 
 describe('RealtimeClientSessionResolver.RelayRealtimeTranscript', () => {
@@ -1690,6 +1726,7 @@ describe('RealtimeClientSessionResolver.SaveSessionChannelArtifact', () => {
     });
 
     it('returns a structured failure when the artifact header save fails (no version attempted)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
         const failingArtifact = makeSessionEntity({
             ID: 'artifact-fail',
             Save: vi.fn(async () => false),
@@ -1706,10 +1743,14 @@ describe('RealtimeClientSessionResolver.SaveSessionChannelArtifact', () => {
 
         expect(result.Success).toBe(false);
         expect(result.ErrorMessage).toMatch(/artifact save failed/i);
+        expect(result.ErrorMessage).toContain('session session-1');
+        expect(result.ErrorMessage).toContain('db down');
+        expect(errSpy.mock.calls.map((call) => String(call[0]))).toContain(result.ErrorMessage);
         expect(version.Save).not.toHaveBeenCalled();
     });
 
     it('returns a structured failure (carrying the orphaned ArtifactID) when the version save fails', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
         const failingVersion = makeSessionEntity({
             ID: 'version-fail',
             Save: vi.fn(async () => false),
@@ -1728,6 +1769,10 @@ describe('RealtimeClientSessionResolver.SaveSessionChannelArtifact', () => {
         expect(result.Success).toBe(false);
         expect(result.ArtifactID).toBe('artifact-1');
         expect(result.ArtifactVersionID).toBeUndefined();
+        expect(result.ErrorMessage).toMatch(/artifact version save failed/i);
+        expect(result.ErrorMessage).toContain('session session-1');
+        expect(result.ErrorMessage).toContain('too big');
+        expect(errSpy.mock.calls.map((call) => String(call[0]))).toContain(result.ErrorMessage);
         expect(junction.Save).not.toHaveBeenCalled();
     });
 
@@ -2880,6 +2925,44 @@ describe('RealtimeClientSessionResolver — scoped-anonymous elevation (issue #3
         expect(executeRelayedToolMock.mock.calls[0][1]).toBe(ANON_USER);
     });
 
+    it('writes the hidden direct-action tool turn (ExecuteRealtimeSessionTool) as the CALLER, not the system user (#4791)', async () => {
+        const detail = makeSessionEntity({ ID: 'detail-1' });
+        currentProvider = {
+            GetEntityObject: vi.fn(async (name: string) =>
+                name === 'MJ: Conversation Details' ? detail : makeSessionEntity({ UserID: 'anon-1' }),
+            ),
+        };
+        executeRelayedToolMock.mockResolvedValue({ ResultJson: '{"success":true}', Success: true });
+        const resolver = makeAnonResolver();
+
+        await resolver.ExecuteRealtimeSessionTool(
+            'session-1', 'call-1', 'Some Direct Action', '{}', makeCtx(), makePubSub(),
+        );
+
+        // The dispatch itself still runs elevated (SYSTEM_USER)…
+        expect(executeRelayedToolMock.mock.calls[0][1]).toBe(SYSTEM_USER);
+        // …but the hidden Conversation Detail turn is written as the CALLER, never the system user.
+        expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: Conversation Details', ANON_USER);
+        expect(getEntityObjectSpy()).not.toHaveBeenCalledWith('MJ: Conversation Details', SYSTEM_USER);
+        expect(detail.Save).toHaveBeenCalled();
+        expect(detail.UserID).toBe('anon-1');
+    });
+
+    it('writes the direct-action tool turn as the caller unchanged for a normal authenticated user', async () => {
+        const detail = makeSessionEntity({ ID: 'detail-2' });
+        currentProvider = {
+            GetEntityObject: vi.fn(async (name: string) => (name === 'MJ: Conversation Details' ? detail : makeSessionEntity())),
+        };
+        executeRelayedToolMock.mockResolvedValue({ ResultJson: '{"success":true}', Success: true });
+        const resolver = makeResolver();
+
+        await resolver.ExecuteRealtimeSessionTool(
+            'session-1', 'call-1', 'Some Direct Action', '{}', makeCtx(), makePubSub(),
+        );
+
+        expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: Conversation Details', USER);
+    });
+
     it('accumulates relayed usage onto the prompt run under the SYSTEM user', async () => {
         const session = makeSessionEntity({
             UserID: 'anon-1',
@@ -2942,6 +3025,32 @@ describe('RealtimeClientSessionResolver — scoped-anonymous elevation (issue #3
         expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: AI Prompt Runs', SYSTEM_USER);
     });
 
+    it('writes the hidden co-agent tool turn (RelayRealtimeToolTurn) as the CALLER (#4791)', async () => {
+        const session = makeSessionEntity({
+            UserID: 'anon-1',
+            Config_: JSON.stringify({ targetAgentID: 'target-1', promptRunID: 'prompt-run-1' }),
+        });
+        const promptRun = makeSessionEntity({ ID: 'prompt-run-1', Messages: null });
+        const detail = makeSessionEntity({ ID: 'detail-3' });
+        currentProvider = {
+            GetEntityObject: vi.fn(async (name: string) => {
+                if (name === 'MJ: AI Prompt Runs') return promptRun;
+                if (name === 'MJ: Conversation Details') return detail;
+                return session;
+            }),
+        };
+        const resolver = makeAnonResolver();
+
+        const ok = await resolver.RelayRealtimeToolTurn('session-1', 'browser_navigate', makeCtx(), '{"url":"x"}');
+
+        expect(ok).toBe(true);
+        // The co-agent run mirror stays SYSTEM…
+        expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: AI Prompt Runs', SYSTEM_USER);
+        // …but the hidden Conversation Detail tool-turn is written as the CALLER, never SYSTEM.
+        expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: Conversation Details', ANON_USER);
+        expect(getEntityObjectSpy()).not.toHaveBeenCalledWith('MJ: Conversation Details', SYSTEM_USER);
+    });
+
     it('prepares the session with observability under the SYSTEM user while UserID stays the visitor', async () => {
         hasPermissionMock.mockResolvedValue(true);
         currentProvider = makeProvider(() => makeSessionEntity({ UserID: 'anon-1' }));
@@ -3003,6 +3112,10 @@ describe('RealtimeClientSessionResolver — scoped-anonymous elevation (issue #3
         // The junction write (an entity the anon role does NOT hold) runs as the SYSTEM user.
         expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: Conversation Detail Artifacts', SYSTEM_USER);
         expect(junctions).toHaveLength(1);
+        // The hidden anchor `Conversation Detail` is written as the CALLER (#4791) — like every
+        // other `MJ: Conversation Details` write, the System user is refused as not the owner.
+        expect(getEntityObjectSpy()).toHaveBeenCalledWith('MJ: Conversation Details', ANON_USER);
+        expect(getEntityObjectSpy()).not.toHaveBeenCalledWith('MJ: Conversation Details', SYSTEM_USER);
         // The hidden anchor is attributed to the SESSION owner, not the elevated principal.
         expect(anchors).toHaveLength(1);
         expect(anchors[0].UserID).toBe('anon-1');
@@ -3102,6 +3215,107 @@ describe('RealtimeClientSessionResolver — scoped-anonymous elevation (issue #3
         expect((storeRecordingMock.mock.calls[0][0] as { ContextUser: unknown }).ContextUser).toBe(USER);
         expect(getSystemUserMock).not.toHaveBeenCalled();
     });
+
+    /** Provider routing a hidden-tool-turn RelayRealtimeToolTurn call: session, prompt run, detail. */
+    function makeToolTurnProvider(detail: FakeSession): unknown {
+        const session = makeSessionEntity({
+            UserID: 'anon-1',
+            Config_: JSON.stringify({ targetAgentID: 'target-1', promptRunID: 'prompt-run-1' }),
+        });
+        const promptRun = makeSessionEntity({ ID: 'prompt-run-1', Messages: null });
+        return {
+            GetEntityObject: vi.fn(async (name: string) => {
+                if (name === 'MJ: AI Prompt Runs') return promptRun;
+                if (name === 'MJ: Conversation Details') return detail;
+                return session;
+            }),
+        };
+    }
+
+    it('logs the session id, write user id and "no failure detail recorded" when a hidden tool turn save is refused without a LatestResult (#4791)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = makeSessionEntity({
+            ID: 'detail-1',
+            Save: vi.fn(async () => false),
+            LatestResult: undefined,
+            ResultHistory: [],
+        });
+        currentProvider = makeToolTurnProvider(detail);
+        const resolver = makeAnonResolver();
+
+        await resolver.RelayRealtimeToolTurn('session-1', 'browser_navigate', makeCtx(), '{}');
+
+        const loggedLines = errSpy.mock.calls.map((call) => String(call[0]));
+        const failureLine = loggedLines.find((line) => line.includes('persistDirectActionTurn'));
+        expect(failureLine).toBeDefined();
+        // Exact substrings: 'anon-1' alone is the caller, session.UserID AND detail.UserID at once,
+        // so only the labelled form proves the WRITE user is what got logged.
+        expect(failureLine).toContain('session session-1');
+        expect(failureLine).toContain('write user anon-1');
+        expect(failureLine).toContain('no failure detail recorded (LatestResult null; ResultHistory length 0)');
+        expect(failureLine).toContain('the write was refused before reaching the provider');
+        expect(failureLine).not.toContain('unknown error');
+    });
+
+    it('does not claim WHERE the write was refused when a result was registered with an empty message (#4791)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = makeSessionEntity({
+            ID: 'detail-1',
+            Save: vi.fn(async () => false),
+            LatestResult: { Success: false, CompleteMessage: '   ' },
+            ResultHistory: [{}],
+        });
+        currentProvider = makeToolTurnProvider(detail);
+        const resolver = makeAnonResolver();
+
+        await resolver.RelayRealtimeToolTurn('session-1', 'browser_navigate', makeCtx(), '{}');
+
+        const loggedLines = errSpy.mock.calls.map((call) => String(call[0]));
+        const failureLine = loggedLines.find((line) => line.includes('persistDirectActionTurn'));
+        expect(failureLine).toBeDefined();
+        expect(failureLine).toContain('no failure detail recorded (LatestResult empty; ResultHistory length 1)');
+        expect(failureLine).not.toContain('refused before reaching the provider');
+    });
+
+    it('never logs a PRIOR SUCCESS entry\'s text as the failure reason when the refusal registered nothing (#4791)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = makeSessionEntity({
+            ID: 'detail-1',
+            Save: vi.fn(async () => false),
+            LatestResult: { Success: true, CompleteMessage: 'previous save ok' },
+            ResultHistory: [{}, {}],
+        });
+        currentProvider = makeToolTurnProvider(detail);
+        const resolver = makeAnonResolver();
+
+        await resolver.RelayRealtimeToolTurn('session-1', 'browser_navigate', makeCtx(), '{}');
+
+        const loggedLines = errSpy.mock.calls.map((call) => String(call[0]));
+        const failureLine = loggedLines.find((line) => line.includes('persistDirectActionTurn'));
+        expect(failureLine).toBeDefined();
+        expect(failureLine).toContain(
+            'no failure detail recorded (latest result entry is a prior success; ResultHistory length 2)',
+        );
+        expect(failureLine).not.toContain('previous save ok');
+    });
+
+    it('logs the real CompleteMessage when present (#4791)', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = makeSessionEntity({
+            ID: 'detail-1',
+            Save: vi.fn(async () => false),
+            LatestResult: { CompleteMessage: 'You do not have access to this conversation.' },
+        });
+        currentProvider = makeToolTurnProvider(detail);
+        const resolver = makeAnonResolver();
+
+        await resolver.RelayRealtimeToolTurn('session-1', 'browser_navigate', makeCtx(), '{}');
+
+        const loggedLines = errSpy.mock.calls.map((call) => String(call[0]));
+        const failureLine = loggedLines.find((line) => line.includes('persistDirectActionTurn'));
+        expect(failureLine).toBeDefined();
+        expect(failureLine).toContain('You do not have access to this conversation.');
+    });
 });
 
 describe('RealtimeClientSessionResolver — colleague authorization (allowedAgents)', () => {

package/src/__tests__/RemoteBrowserActionRecovery.test.ts

@@ -59,7 +59,13 @@ vi.mock('@memberjunction/remote-browser-server', () => ({
 }));
 
 vi.mock('@memberjunction/aiengine', () => ({ AIEngine: { Instance: { Config: vi.fn(), Prompts: [] } } }));
-vi.mock('@memberjunction/ai-prompts', () => ({ AIPromptRunner: class {} }));
+// Spread the real module, as for ai-core-plus below, so transitively-loaded modules resolve: runners such as
+// AIRerankerRunner (which extends BaseModelRunner), and RunDecisionResolver's AIDecisionRunner. Only
+// AIPromptRunner is overridden for the test.
+vi.mock('@memberjunction/ai-prompts', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@memberjunction/ai-prompts')>()),
+  AIPromptRunner: class {},
+}));
 vi.mock('@memberjunction/ai-core-plus', async (importOriginal) => ({
   ...(await importOriginal<typeof import('@memberjunction/ai-core-plus')>()),
   AIPromptParams: class {},

package/src/__tests__/RemoteBrowserAudioStream.test.ts

@@ -72,7 +72,13 @@ vi.mock('@memberjunction/remote-browser-server', () => ({
 
 // Keep the AI imports (visual interpreter) inert — they aren't exercised by the audio path.
 vi.mock('@memberjunction/aiengine', () => ({ AIEngine: { Instance: { Config: vi.fn(), Prompts: [] } } }));
-vi.mock('@memberjunction/ai-prompts', () => ({ AIPromptRunner: class {} }));
+// Spread the real module, as for ai-core-plus below, so transitively-loaded modules resolve: runners such as
+// AIRerankerRunner (which extends BaseModelRunner), and RunDecisionResolver's AIDecisionRunner. Only
+// AIPromptRunner is overridden for the test.
+vi.mock('@memberjunction/ai-prompts', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@memberjunction/ai-prompts')>()),
+  AIPromptRunner: class {},
+}));
 // Spread the real module so transitively-loaded code (e.g. ArtifactToolManager → DataSnapshotToolLibrary,
 // which extends BaseArtifactToolLibrary) still resolves with its REAL base classes; only AIPromptParams is
 // overridden for the test. (Subsumes the narrower stub-two-exports approach — any other transitive export

package/src/__tests__/RemoteBrowserSnapshot.test.ts

@@ -62,7 +62,13 @@ vi.mock('@memberjunction/remote-browser-server', () => ({
 
 // Keep the AI imports (visual interpreter) inert — they aren't exercised by the snapshot path.
 vi.mock('@memberjunction/aiengine', () => ({ AIEngine: { Instance: { Config: vi.fn(), Prompts: [] } } }));
-vi.mock('@memberjunction/ai-prompts', () => ({ AIPromptRunner: class {} }));
+// Spread the real module, as for ai-core-plus below, so transitively-loaded modules resolve: runners such as
+// AIRerankerRunner (which extends BaseModelRunner), and RunDecisionResolver's AIDecisionRunner. Only
+// AIPromptRunner is overridden for the test.
+vi.mock('@memberjunction/ai-prompts', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@memberjunction/ai-prompts')>()),
+  AIPromptRunner: class {},
+}));
 // Spread the real module so transitively-loaded code still resolves with its REAL base classes; only
 // AIPromptParams is overridden for the test.
 vi.mock('@memberjunction/ai-core-plus', async (importOriginal) => ({