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

package/src/__tests__/RemoteBrowserGoalEngine.test.ts

@@ -5,11 +5,11 @@ import { MJComputerUseEngine, MJRunComputerUseParams } from '@memberjunction/com
 import { CdpRemoteBrowserSession, type ComputerUseGoalRun } from '@memberjunction/remote-browser-cdp';
 import type { MJAIAgentRunStepEntity } from '@memberjunction/core-entities';
 import {
-  buildMJGoalParams,
+  BuildMJGoalParams,
   BindRemoteBrowserGoalEngine,
   MJProgressComputerUseEngine,
-  extractCoAgentRunID,
-  finalizeBrowserGoalStep,
+  ExtractCoAgentRunID,
+  FinalizeBrowserGoalStep,
 } from '../agentSessions/remoteBrowserGoalEngine.js';
 
 const USER = { ID: 'u-1', Email: 'amith@bluecypress.io' } as unknown as UserInfo;
@@ -21,7 +21,7 @@ function baseParams(): RunComputerUseParams {
 
 describe('buildMJGoalParams', () => {
   it('produces MJ-aware params that carry over the base goal/step/url fields', () => {
-    const mj = buildMJGoalParams(baseParams(), USER);
+    const mj = BuildMJGoalParams(baseParams(), USER);
     expect(mj).toBeInstanceOf(MJRunComputerUseParams);
     expect(mj.Goal).toBe('log in');
     expect(mj.MaxSteps).toBe(7);
@@ -29,21 +29,21 @@ describe('buildMJGoalParams', () => {
   });
 
   it('injects the acting ContextUser so MJ prompts run as that user', () => {
-    expect(buildMJGoalParams(baseParams(), USER).ContextUser).toBe(USER);
+    expect(BuildMJGoalParams(baseParams(), USER).ContextUser).toBe(USER);
   });
 
   it('leaves ContextUser undefined when none is supplied', () => {
-    expect(buildMJGoalParams(baseParams()).ContextUser).toBeUndefined();
+    expect(BuildMJGoalParams(baseParams()).ContextUser).toBeUndefined();
   });
 
   it('threads the parent run + step ids for observability nesting', () => {
-    const mj = buildMJGoalParams(baseParams(), USER, 'coagent-run-1', 'goal-step-1');
+    const mj = BuildMJGoalParams(baseParams(), USER, 'coagent-run-1', 'goal-step-1');
     expect(mj.AgentRunId).toBe('coagent-run-1');
     expect(mj.AgentRunStepID).toBe('goal-step-1');
   });
 
   it('leaves the run/step ids undefined when not supplied', () => {
-    const mj = buildMJGoalParams(baseParams(), USER);
+    const mj = BuildMJGoalParams(baseParams(), USER);
     expect(mj.AgentRunId).toBeUndefined();
     expect(mj.AgentRunStepID).toBeUndefined();
   });
@@ -51,17 +51,17 @@ describe('buildMJGoalParams', () => {
 
 describe('extractCoAgentRunID', () => {
   it('pulls coAgentRunID out of a session Config_ blob', () => {
-    expect(extractCoAgentRunID(JSON.stringify({ coAgentRunID: 'run-9', promptRunID: 'p' }))).toBe('run-9');
+    expect(ExtractCoAgentRunID(JSON.stringify({ coAgentRunID: 'run-9', promptRunID: 'p' }))).toBe('run-9');
   });
   it('returns undefined for a missing key, null/empty config, or non-string value', () => {
-    expect(extractCoAgentRunID(JSON.stringify({ promptRunID: 'p' }))).toBeUndefined();
-    expect(extractCoAgentRunID(null)).toBeUndefined();
-    expect(extractCoAgentRunID(undefined)).toBeUndefined();
-    expect(extractCoAgentRunID('')).toBeUndefined();
-    expect(extractCoAgentRunID(JSON.stringify({ coAgentRunID: 123 }))).toBeUndefined();
+    expect(ExtractCoAgentRunID(JSON.stringify({ promptRunID: 'p' }))).toBeUndefined();
+    expect(ExtractCoAgentRunID(null)).toBeUndefined();
+    expect(ExtractCoAgentRunID(undefined)).toBeUndefined();
+    expect(ExtractCoAgentRunID('')).toBeUndefined();
+    expect(ExtractCoAgentRunID(JSON.stringify({ coAgentRunID: 123 }))).toBeUndefined();
   });
   it('returns undefined for malformed JSON (best-effort)', () => {
-    expect(extractCoAgentRunID('{not json')).toBeUndefined();
+    expect(ExtractCoAgentRunID('{not json')).toBeUndefined();
   });
 });
 
@@ -76,7 +76,7 @@ describe('finalizeBrowserGoalStep', () => {
 
   it('finalizes the parent step Completed from a successful goal result + saves', async () => {
     const step = fakeStep();
-    await finalizeBrowserGoalStep(step, { Success: true, Strategy: 'ComputerUse', Status: 'Completed', StepCount: 4, CurrentUrl: 'https://done/' });
+    await FinalizeBrowserGoalStep(step, { Success: true, Strategy: 'ComputerUse', Status: 'Completed', StepCount: 4, CurrentUrl: 'https://done/' });
     expect(step.Status).toBe('Completed');
     expect(step.Success).toBe(true);
     expect((step as unknown as { Save: ReturnType<typeof vi.fn> }).Save).toHaveBeenCalledOnce();
@@ -87,13 +87,13 @@ describe('finalizeBrowserGoalStep', () => {
 
   it('finalizes Failed and carries the detail as the error message', async () => {
     const step = fakeStep();
-    await finalizeBrowserGoalStep(step, { Success: false, Status: 'Error', Detail: 'login blocked' });
+    await FinalizeBrowserGoalStep(step, { Success: false, Status: 'Error', Detail: 'login blocked' });
     expect(step.Status).toBe('Failed');
     expect(step.ErrorMessage).toBe('login blocked');
   });
 
   it('is a no-op when the step is null (no co-agent run to nest under)', async () => {
-    await expect(finalizeBrowserGoalStep(null, { Success: true })).resolves.toBeUndefined();
+    await expect(FinalizeBrowserGoalStep(null, { Success: true })).resolves.toBeUndefined();
   });
 });
 

package/src/__tests__/RunAIAgentResolver.historyFrom.test.ts

@@ -0,0 +1,228 @@
+/**
+ * @fileoverview The agent's history floor on `RunAIAgentFromConversationDetail`.
+ *
+ * `agentHistoryFrom` is the one server change behind the conversations host rules: an optional
+ * ISO-8601 timestamp, the first moment of the conversation a run may read. These tests pin that
+ * the mutation parses it before anything loads, fails the request on an unreadable value instead
+ * of dropping it, loads history from it (in the query AND in the window assembly), and hands it to
+ * the agent run as `ConversationHistoryFrom` on both the synchronous and fire-and-forget paths —
+ * and that leaving it out changes nothing.
+ */
+import 'reflect-metadata'; // must precede any type-graphql decorator evaluation
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { PubSubEngine } from 'type-graphql';
+
+// type-graphql's real decorators need emitDecoratorMetadata, which vitest's esbuild transform
+// does not emit; the schema is irrelevant here, so every decorator is a no-op.
+vi.mock('type-graphql', () => {
+    const decoratorFactory = (..._args: unknown[]) => (..._decorated: unknown[]) => undefined;
+    const exportNames = [
+        'Resolver', 'Query', 'Mutation', 'Subscription', 'Arg', 'Args', 'ArgsType', 'Ctx', 'Root',
+        'Info', 'Field', 'FieldResolver', 'ObjectType', 'InputType', 'InterfaceType', 'Authorized',
+        'UseMiddleware', 'Extensions', 'Directive', 'ID', 'Int', 'Float', 'GraphQLISODateTime',
+        'GraphQLTimestamp', 'registerEnumType', 'createMethodDecorator', 'createParamDecorator',
+        'buildSchema', 'buildSchemaSync', 'PubSub',
+    ];
+    return Object.fromEntries(exportNames.map((name) => [name, decoratorFactory]));
+});
+
+const hoisted = vi.hoisted(() => ({
+    runAgentInConversation: vi.fn(),
+}));
+
+vi.mock('@memberjunction/ai-agents', () => ({
+    AgentRunner: class {
+        RunAgentInConversation(...args: unknown[]) {
+            return hoisted.runAgentInConversation(...args);
+        }
+    },
+    ArtifactToolManager: class {},
+}));
+
+vi.mock('../realtimeWidget/widgetGuestElevation.js', () => ({
+    ResolveWidgetGuestRunContext: vi.fn().mockResolvedValue(null),
+    ElevateUserPayload: vi.fn(),
+}));
+
+import { ConversationEngine } from '@memberjunction/core-entities';
+import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import type { AppContext, UserPayload } from '../types.js';
+
+const FLOOR_ISO = '2026-09-01T12:00:00.000Z';
+const USER = { ID: 'user-1', Email: 'user@example.com' };
+
+type Fn = ReturnType<typeof vi.fn>;
+
+/** The private members this test reaches, through an explicit shape (no `any`). */
+interface ResolverSeams {
+    CheckAPIKeyScopeAuthorization: Fn;
+    GetUserFromPayload: Fn;
+    loadConversationHistoryWithAttachments: Fn;
+    executeAIAgent: Fn;
+    executeAgentInBackground: Fn;
+    loadInputArtifactsBatch: Fn;
+    validateAgent: Fn;
+    persistInFlightAgentFailure: Fn;
+}
+
+function makeResolver(): { resolver: RunAIAgentResolver; seams: ResolverSeams } {
+    const resolver = new RunAIAgentResolver();
+    const seams = resolver as unknown as ResolverSeams;
+    seams.CheckAPIKeyScopeAuthorization = vi.fn().mockResolvedValue(undefined);
+    seams.GetUserFromPayload = vi.fn().mockReturnValue(USER);
+    return { resolver, seams };
+}
+
+function makeContext(): AppContext {
+    const provider = {
+        GetEntityObject: vi.fn().mockResolvedValue({
+            ConversationID: 'conv-1',
+            Load: vi.fn().mockResolvedValue(true),
+        }),
+    };
+    return {
+        userPayload: { sessionId: 'session-1', userRecord: USER } as unknown as UserPayload,
+        providers: [{ type: 'Read-Write', provider }],
+        dataSource: {},
+    } as unknown as AppContext;
+}
+
+const pubSub = { publish: vi.fn() } as unknown as PubSubEngine;
+
+async function runMutation(
+    resolver: RunAIAgentResolver,
+    options: { agentHistoryFrom?: string; fireAndForget?: boolean }
+) {
+    return resolver.RunAIAgentFromConversationDetail(
+        'detail-1', 'agent-1', makeContext(), 'session-1', pubSub,
+        undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+        undefined, undefined, options.fireAndForget, undefined, undefined,
+        options.agentHistoryFrom
+    );
+}
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('RunAIAgentFromConversationDetail — agentHistoryFrom', () => {
+    let resolver: RunAIAgentResolver;
+    let seams: ResolverSeams;
+
+    beforeEach(() => {
+        ({ resolver, seams } = makeResolver());
+        seams.loadConversationHistoryWithAttachments = vi.fn().mockResolvedValue([]);
+        seams.executeAIAgent = vi.fn().mockResolvedValue({ success: true, result: '{}' });
+        seams.executeAgentInBackground = vi.fn();
+    });
+
+    it('loads history from the floor and hands the floor to the run', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: FLOOR_ISO });
+
+        expect(result.success).toBe(true);
+        const loaderArgs = seams.loadConversationHistoryWithAttachments.mock.calls[0];
+        expect(loaderArgs[0]).toBe('conv-1');
+        expect(loaderArgs[4]).toEqual(['detail-1']);
+        expect((loaderArgs[5] as Date).toISOString()).toBe(FLOOR_ISO);
+        const runFloor = seams.executeAIAgent.mock.calls[0].at(-1) as Date;
+        expect(runFloor.toISOString()).toBe(FLOOR_ISO);
+    });
+
+    it('hands the floor to a fire-and-forget run too', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: FLOOR_ISO, fireAndForget: true });
+
+        expect(result.success).toBe(true);
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+        const runFloor = seams.executeAgentInBackground.mock.calls[0].at(-1) as Date;
+        expect(runFloor.toISOString()).toBe(FLOOR_ISO);
+    });
+
+    it('left out, reads the whole conversation as before', async () => {
+        await runMutation(resolver, {});
+
+        expect(seams.loadConversationHistoryWithAttachments.mock.calls[0][5]).toBeUndefined();
+        expect(seams.executeAIAgent.mock.calls[0].at(-1)).toBeUndefined();
+    });
+
+    it('fails the request on an unreadable floor, before loading or running anything', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: 'last tuesday' });
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toContain('agentHistoryFrom');
+        expect(seams.loadConversationHistoryWithAttachments).not.toHaveBeenCalled();
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+        expect(seams.executeAgentInBackground).not.toHaveBeenCalled();
+    });
+
+    it('treats an empty string as unreadable too, never as "no floor"', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: '' });
+
+        expect(result.success).toBe(false);
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+    });
+});
+
+describe('loadConversationHistoryWithAttachments — history floor', () => {
+    it('passes the floor to the fresh loader and to the window assembly', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.loadInputArtifactsBatch = vi.fn().mockResolvedValue(new Map());
+        const loadRows = vi.spyOn(ConversationEngine, 'LoadWindowRowsFresh').mockResolvedValue([]);
+        const assemble = vi.spyOn(ConversationEngine, 'AssembleContextWindow');
+        const floor = new Date(FLOOR_ISO);
+        const provider = {};
+
+        const load = (resolver as unknown as {
+            loadConversationHistoryWithAttachments(
+                conversationId: string, user: unknown, max: number, provider: unknown, exclude?: string[], historyFrom?: Date
+            ): Promise<unknown[]>;
+        }).loadConversationHistoryWithAttachments.bind(resolver);
+        await load('conv-1', USER, 20, provider, ['detail-1'], floor);
+
+        expect(loadRows).toHaveBeenCalledWith('conv-1', USER, provider, floor);
+        expect(assemble.mock.calls[0][1]).toEqual({ maxTailMessages: 20, excludeDetailIds: ['detail-1'], historyFrom: floor });
+    });
+});
+
+describe('executeAIAgent — ConversationHistoryFrom', () => {
+    function wire() {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        seams.persistInFlightAgentFailure = vi.fn().mockResolvedValue(undefined);
+        // Stop right after the params are captured — the rest of the run is out of scope, and so
+        // is the failure it logs.
+        hoisted.runAgentInConversation.mockReset().mockRejectedValue(new Error('stop here'));
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean }>;
+        }).executeAIAgent.bind(resolver);
+        return execute;
+    }
+
+    function positional(conversationHistoryFrom?: Date): unknown[] {
+        const userPayload = { sessionId: 'session-1', userRecord: USER };
+        return [
+            {}, {}, 'agent-1', userPayload, '[{"role":"user","content":"hi"}]', 'session-1', pubSub,
+            undefined, undefined, undefined, undefined, undefined, undefined, 'detail-1', false, false,
+            undefined, undefined, 'conv-1', undefined, undefined, undefined, undefined,
+            conversationHistoryFrom,
+        ];
+    }
+
+    it('puts the floor on the run\'s params', async () => {
+        const execute = wire();
+        const floor = new Date(FLOOR_ISO);
+        await execute(...positional(floor));
+
+        const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
+        expect(params.ConversationHistoryFrom).toBe(floor);
+    });
+
+    it('leaves it unset without a floor', async () => {
+        const execute = wire();
+        await execute(...positional());
+
+        const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
+        expect(params.ConversationHistoryFrom).toBeUndefined();
+    });
+});

package/src/__tests__/TaskGraphActionRunner.durablePayload.test.ts

@@ -0,0 +1,129 @@
+/**
+ * End-to-end-in-miniature regression test for #4794.
+ *
+ * The bug: `BuildDurableDeferral` persisted a durable entity action's redacted params as a
+ * `LoggedParam[]` ARRAY (`RedactParamsToJSON`'s shape), while `TaskGraphActionRunner.buildParams`
+ * reads `Task.InputPayload` back as a name→value RECORD. Every released build with durable dispatch
+ * (v6.1.0 onward, including 6.1.4) hit the same real-world failure: `TaskGraphDispatcher`'s
+ * `mergedPayload` only merges plain objects, so it silently dropped the array before `buildParams`
+ * ever saw it, and the action ran with NONE of its declared inputs. `buildParams` itself has no such
+ * guard — `Object.assign(merged, arrayValue)` treats an array's indices as keys — so params named
+ * `'0'`, `'1'`, ... would only appear if the array reached it directly, bypassing the dispatcher's
+ * drop. That narrower path is exactly what this test exercises, by calling `RunActionForTask`
+ * on its own rather than through the dispatcher.
+ *
+ * This test proves the whole pipe, not just the writer or the reader in isolation: build the
+ * payload exactly as the deferral does (`RedactParamsToRecord`), push it through the same
+ * `JSON.stringify` / `JSON.parse` round trip `TaskGraphService` performs to persist and reload
+ * `Task.InputPayload`, then run it through the real `TaskGraphActionRunner` and assert the action
+ * receives its declared parameters BY NAME.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@memberjunction/actions', () => ({
+    ActionEngineServer: {
+        Instance: {
+            Config: vi.fn(),
+            Actions: [{ ID: 'A1', Name: 'Log Activity' }],
+            RunAction: vi.fn(),
+        },
+    },
+}));
+
+import { ActionEngineServer } from '@memberjunction/actions';
+import { RedactParamsToRecord, ActionParam } from '@memberjunction/actions-base';
+import type { MJActionExecutionLogEntity, MJActionParamEntity, MJEntityActionParamEntity } from '@memberjunction/core-entities';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { TaskActionRunParams } from '@memberjunction/task-graph';
+import { TaskGraphActionRunner } from '../services/TaskGraphActionRunner';
+
+// ── Test fixture builders — same shape as packages/Actions/Base/src/__tests__/ParamRedaction.test.ts ──
+
+function actionParam(name: string, value: unknown): ActionParam {
+    return { Name: name, Value: value, Type: 'Input' } as ActionParam;
+}
+
+function definition(id: string, name: string, logValue: boolean = true): MJActionParamEntity {
+    return { ID: id, Name: name, LogValue: logValue } as MJActionParamEntity;
+}
+
+function binding(actionParamID: string, valueType: string, logValue: boolean | null = null): MJEntityActionParamEntity {
+    return { ActionParamID: actionParamID, ValueType: valueType, LogValue: logValue } as MJEntityActionParamEntity;
+}
+
+// The declared parameters for the durable entity action under test: three that log normally, and
+// one ("InternalNotes") whose binding opts out of logging (rule 2 in ParamRedaction.ts).
+const RUNTIME_PARAMS: ActionParam[] = [
+    actionParam('TypeCode', 'SystemEvent'),
+    actionParam('Title', 'Person created'),
+    actionParam('RecordID', 'REC-123'),
+    actionParam('InternalNotes', 'do not persist this'),
+];
+const ACTION_PARAMS: MJActionParamEntity[] = [
+    definition('p1', 'TypeCode'),
+    definition('p2', 'Title'),
+    definition('p3', 'RecordID'),
+    definition('p4', 'InternalNotes'),
+];
+const ENTITY_ACTION_PARAMS: MJEntityActionParamEntity[] = [binding('p4', 'Static', false)];
+
+function baseRunParams(inputPayload: unknown): TaskActionRunParams {
+    return {
+        TaskID: 'T1',
+        ActionID: 'A1',
+        InputPayload: inputPayload,
+        DependencyOutputs: new Map(),
+        Provider: {} as IMetadataProvider,
+        ContextUser: {} as UserInfo,
+    };
+}
+
+describe('TaskGraphActionRunner — durable payload round-trips by param name (#4794)', () => {
+    beforeEach(() => {
+        // vitest's `restoreMocks: true` clears mock implementations before every test, including
+        // the ones assigned inside the `vi.mock` factory above — so the return value is (re)armed here.
+        vi.mocked(ActionEngineServer.Instance.Config).mockResolvedValue(undefined);
+        vi.mocked(ActionEngineServer.Instance.RunAction, { partial: true }).mockResolvedValue({
+            Success: true,
+            Params: [],
+            LogEntry: { ID: 'L1' } as MJActionExecutionLogEntity,
+        });
+    });
+
+    it('delivers RedactParamsToRecord\'s output to the action by name, after a JSON round trip', async () => {
+        // Exactly what the deferral writes, then exactly what TaskGraphService's JSON column does to it.
+        const stored = JSON.parse(JSON.stringify(RedactParamsToRecord(RUNTIME_PARAMS, ACTION_PARAMS, ENTITY_ACTION_PARAMS)));
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams(stored));
+
+        expect(result.Success).toBe(true);
+        expect(result.ActionLogID).toBe('L1');
+
+        const runActionCall = vi.mocked(ActionEngineServer.Instance.RunAction).mock.calls[0][0];
+        const sentParams = runActionCall.Params as ActionParam[];
+
+        // The three logged declared names arrive, order-insensitive, with their values intact.
+        expect(sentParams.map((p) => p.Name).sort()).toEqual(['RecordID', 'Title', 'TypeCode']);
+        expect(sentParams.find((p) => p.Name === 'TypeCode')?.Value).toBe('SystemEvent');
+        expect(sentParams.find((p) => p.Name === 'Title')?.Value).toBe('Person created');
+        expect(sentParams.find((p) => p.Name === 'RecordID')?.Value).toBe('REC-123');
+
+        // The binding-suppressed parameter never reaches the action — absent, not present-with-undefined.
+        expect(sentParams.some((p) => p.Name === 'InternalNotes')).toBe(false);
+    });
+
+    it('does not turn dependency outputs into params named by the upstream task ID', async () => {
+        // The dispatcher keys DependencyOutputs by the upstream task's ID and has ALREADY merged their
+        // values into InputPayload (TaskGraphDispatcher.mergedPayload). A runner that also spread the
+        // map handed the action one extra param per dependency, named by a GUID and holding that
+        // task's whole output — which then landed, unredacted, in ActionExecutionLog.Params.
+        const upstreamID = '20924BD7-5128-4150-8404-FB44A55AEA0F';
+        const params = baseRunParams({ EntityName: 'MJ: Entities', Record: { ID: 'R1', Name: 'MJ: Tags' } });
+        params.DependencyOutputs = new Map([[upstreamID, { Record: { ID: 'R1', Name: 'MJ: Tags' } }]]);
+
+        await new TaskGraphActionRunner().RunActionForTask(params);
+
+        const sentParams = vi.mocked(ActionEngineServer.Instance.RunAction).mock.calls[0][0].Params as ActionParam[];
+        expect(sentParams.map((p) => p.Name).sort()).toEqual(['EntityName', 'Record']);
+    });
+});

package/src/__tests__/TaskGraphFrameResolver.test.ts

@@ -19,7 +19,7 @@ vi.mock('@memberjunction/core', () => ({ LogError: vi.fn() }));
 import {
     TASK_GRAPH_FRAMES_TOPIC,
     TaskGraphFrameBroadcaster,
-    taskGraphFrameFilter,
+    TaskGraphFrameFilter,
     type TaskGraphFramePayload,
 } from '../resolvers/TaskGraphFrameResolver';
 import type { TaskGraphFrame } from '@memberjunction/task-graph';
@@ -44,7 +44,7 @@ const payload = (over: Partial<TaskGraphFramePayload> = {}): TaskGraphFramePaylo
 const context = (userId: string | null) => (userId ? { userPayload: { userRecord: { ID: userId } } } : {});
 
 const check = (over: Partial<TaskGraphFramePayload> = {}, args = GRAPH, userId: string | null = OWNER) =>
-    taskGraphFrameFilter({ payload: payload(over), args: { parentTaskId: args }, context: context(userId) });
+    TaskGraphFrameFilter({ payload: payload(over), args: { parentTaskId: args }, context: context(userId) });
 
 describe('taskGraphFrameFilter — the delivery gate', () => {
     it('delivers a frame for the watched graph to its owner', () => {

package/src/__tests__/WidgetSessionService.test.ts

@@ -21,12 +21,16 @@ vi.mock('../auth/magicLink/MagicLinkService.js', () => ({
   MagicLinkService: class {},
 }));
 vi.mock('../agentSessions/ReturningVisitorRecap.js', () => ({
-  writeReturningVisitorRecap: async () => undefined,
+  WriteReturningVisitorRecap: async () => undefined,
+    get writeReturningVisitorRecap() { return this.WriteReturningVisitorRecap; },
 }));
 vi.mock('../realtimeWidget/visitorIdentity.js', () => ({
-  resolveIdentityByEmail: async () => null,
-  mergeVisitorIdentity: async () => 0,
-  forgetVisitor: async () => ({ notesArchived: 0, conversationsCleared: 0 }),
+  ResolveIdentityByEmail: async () => null,
+    get resolveIdentityByEmail() { return this.ResolveIdentityByEmail; },
+  MergeVisitorIdentity: async () => 0,
+    get mergeVisitorIdentity() { return this.MergeVisitorIdentity; },
+  ForgetVisitor: async () => ({ notesArchived: 0, conversationsCleared: 0 }),
+    get forgetVisitor() { return this.ForgetVisitor; },
 }));
 
 import { WidgetSessionService } from '../realtimeWidget/WidgetSessionService.js';

package/src/__tests__/adhoc-query-helpers.test.ts

@@ -1,50 +1,50 @@
 import { describe, it, expect } from 'vitest';
-import { exactTotalFromPage, resolveAdhocTotalRowCount } from '../resolvers/adhoc-query-helpers';
+import { ExactTotalFromPage, ResolveAdhocTotalRowCount } from '../resolvers/adhoc-query-helpers';
 
 describe('exactTotalFromPage', () => {
     it('returns the row count when not paging (maxRows null) — the query was uncapped', () => {
-        expect(exactTotalFromPage(0, 47, null)).toBe(47);
-        expect(exactTotalFromPage(0, 0, null)).toBe(0);
+        expect(ExactTotalFromPage(0, 47, null)).toBe(47);
+        expect(ExactTotalFromPage(0, 0, null)).toBe(0);
     });
 
     it('returns startRow + pageLength for a SHORT page (fewer rows than the page size)', () => {
-        expect(exactTotalFromPage(0, 47, 100)).toBe(47);   // page 1, short → exact total
-        expect(exactTotalFromPage(200, 30, 100)).toBe(230); // page 3, short last page
-        expect(exactTotalFromPage(100, 0, 100)).toBe(100);  // empty page past the end
+        expect(ExactTotalFromPage(0, 47, 100)).toBe(47);   // page 1, short → exact total
+        expect(ExactTotalFromPage(200, 30, 100)).toBe(230); // page 3, short last page
+        expect(ExactTotalFromPage(100, 0, 100)).toBe(100);  // empty page past the end
     });
 
     it('returns null for a FULL page — a COUNT is required because more rows may exist', () => {
-        expect(exactTotalFromPage(0, 100, 100)).toBeNull();
-        expect(exactTotalFromPage(500, 100, 100)).toBeNull();
+        expect(ExactTotalFromPage(0, 100, 100)).toBeNull();
+        expect(ExactTotalFromPage(500, 100, 100)).toBeNull();
     });
 
     it('treats an over-full page defensively as "needs count" (should not occur with OFFSET/FETCH)', () => {
-        expect(exactTotalFromPage(0, 150, 100)).toBeNull();
+        expect(ExactTotalFromPage(0, 150, 100)).toBeNull();
     });
 });
 
 describe('resolveAdhocTotalRowCount', () => {
     it('reads TotalRowCount from the count recordset', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 2087 }], 100)).toBe(2087);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 0 }], 100)).toBe(0);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: 2087 }], 100)).toBe(2087);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: 0 }], 100)).toBe(0);
     });
 
     it('floors a fractional/stringified count', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 42.9 }], 0)).toBe(42);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: '2087' as unknown as number }], 0)).toBe(2087);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: 42.9 }], 0)).toBe(42);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: '2087' as unknown as number }], 0)).toBe(2087);
     });
 
     it('falls back when the count is absent, empty, null, or malformed', () => {
-        expect(resolveAdhocTotalRowCount(null, 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount(undefined, 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{}], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: null }], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount(null, 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount(undefined, 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([{}], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: null }], 100)).toBe(100);
     });
 
     it('falls back on non-finite or negative counts (never reports a misleading total)', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: Number.NaN }], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: -5 }], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: Infinity }], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: Number.NaN }], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: -5 }], 100)).toBe(100);
+        expect(ResolveAdhocTotalRowCount([{ TotalRowCount: Infinity }], 100)).toBe(100);
     });
 });

package/src/__tests__/bootAudit.test.ts

@@ -18,7 +18,7 @@ vi.mock('../config.js', () => ({
   },
 }));
 
-import { auditResolverList } from '../logging/bootAudit.js';
+import { AuditResolverList } from '../logging/bootAudit.js';
 import type { AuditArgParam, AuditResolver } from '../logging/bootAudit.js';
 import { NoLog } from '../logging/NoLog.js';
 
@@ -37,12 +37,12 @@ function makeArgParam(opts: {
   type: Function;
 }): AuditArgParam {
   return {
-    target: opts.target,
-    methodName: opts.methodName,
-    index: opts.index,
+    Target: opts.target,
+    MethodName: opts.methodName,
+    Index: opts.index,
     kind: 'arg',
     name: opts.name,
-    getType: () => opts.type,
+    GetType: () => opts.type,
   };
 }
 
@@ -52,8 +52,8 @@ function makeResolver(opts: {
   params: AuditArgParam[];
 }): AuditResolver {
   return {
-    target: opts.target,
-    methodName: opts.methodName,
+    Target: opts.target,
+    MethodName: opts.methodName,
     params: opts.params,
   };
 }
@@ -93,7 +93,7 @@ describe('auditResolverList', () => {
       ],
     });
 
-    auditResolverList([resolver]);
+    AuditResolverList([resolver]);
     expect(warnSpy).not.toHaveBeenCalled();
   });
 
@@ -117,7 +117,7 @@ describe('auditResolverList', () => {
       ],
     });
 
-    auditResolverList([resolver]);
+    AuditResolverList([resolver]);
     expect(warnSpy).toHaveBeenCalledTimes(1);
     const message = warnSpy.mock.calls[0][0];
     expect(typeof message).toBe('string');
@@ -148,7 +148,7 @@ describe('auditResolverList', () => {
       ],
     });
 
-    auditResolverList([resolver]);
+    AuditResolverList([resolver]);
     expect(warnSpy).not.toHaveBeenCalled();
   });
 
@@ -179,7 +179,7 @@ describe('auditResolverList', () => {
       ],
     });
 
-    auditResolverList([resolver]);
+    AuditResolverList([resolver]);
     expect(warnSpy).toHaveBeenCalledTimes(1);
     const message = warnSpy.mock.calls[0][0];
     expect(message).toContain("'custom'");