fix: 6017 link manually-selected tool on policy/tool import

guardian-service/src/helpers/import-helpers/policy/policy-import.ts

@@ -46,6 +46,7 @@ import { SchemaImportExportHelper } from '../schema/schema-import-helper.js';
 import { importTag } from '../tag/tag-import-helper.js';
 import { ImportToolMap, ImportToolResults } from '../tool/tool-import.interface.js';
 import { importSubTools } from '../tool/tool-import-helper.js';
+import { resolveToolOverrides } from '../tool/tool-override-resolver.js';
 import { ImportTokenMap, ImportTokenResult } from '../token/token-import.interface.js';
 import { ImportArtifactResult } from '../artifact/artifact-import.interface.js';
 import { importTokensByFiles } from '../token/token-import-helper.js';
@@ -375,24 +376,11 @@ export class PolicyImport {
     ) {
         step.start();
 
-        this.toolsMapping = [];
-        if (metadata?.tools) {
-            for (const tool of tools) {
-                if (
-                    metadata.tools[tool.messageId] &&
-                    tool.messageId !== metadata.tools[tool.messageId]
-                ) {
-                    this.toolsMapping.push({
-                        oldMessageId: tool.messageId,
-                        messageId: metadata.tools[tool.messageId],
-                        oldHash: tool.hash,
-                    });
-                    tool.messageId = metadata.tools[tool.messageId];
-                }
-            }
-        }
+        const { toolsMapping, preResolvedTools, toolsToImport } = await resolveToolOverrides(tools, metadata);
+        this.toolsMapping = toolsMapping;
 
-        this.toolsResult = await importSubTools(this.root, tools, user, step, userId);
+        this.toolsResult = await importSubTools(this.root, toolsToImport, user, step, userId);
+        this.toolsResult.tools = [...preResolvedTools, ...this.toolsResult.tools];
 
         for (const toolMapping of this.toolsMapping) {
             const toolByMessageId = this.toolsResult.tools.find((tool) => tool.messageId === toolMapping.messageId);

guardian-service/src/helpers/import-helpers/tool/tool-import-helper.ts

@@ -3,6 +3,7 @@ import { DatabaseServer, INotificationStep, IToolComponents, MessageAction, Mess
 import { importTag } from '../tag/tag-import-helper.js';
 import { SchemaImportExportHelper } from '../schema/schema-import-helper.js';
 import { ImportToolMap, ImportToolResult, ImportToolResults } from './tool-import.interface.js';
+import { resolveToolOverrides } from './tool-override-resolver.js';
 
 /**
  * Import tools by messages
@@ -366,28 +367,7 @@ export async function importToolByFile(
     const users = new Users();
     const root = await users.getHederaAccount(user.creator, userId);
 
-    const toolsMapping: {
-        oldMessageId: string;
-        messageId: string;
-        oldHash: string;
-        newHash?: string;
-    }[] = [];
-    if (metadata?.tools) {
-        // tslint:disable-next-line:no-shadowed-variable
-        for (const tool of tools) {
-            if (
-                metadata.tools[tool.messageId] &&
-                tool.messageId !== metadata.tools[tool.messageId]
-            ) {
-                toolsMapping.push({
-                    oldMessageId: tool.messageId,
-                    messageId: metadata.tools[tool.messageId],
-                    oldHash: tool.hash,
-                });
-                tool.messageId = metadata.tools[tool.messageId];
-            }
-        }
-    }
+    const { toolsMapping, preResolvedTools, toolsToImport } = await resolveToolOverrides(tools, metadata);
 
     delete tool._id;
     delete tool.id;
@@ -461,16 +441,16 @@ export async function importToolByFile(
     notifier.startStep(STEP_IMPORT_SUB_SCHEMAS);
     const toolsResult = await importSubTools(
         root,
-        tools,
+        toolsToImport,
         user,
         notifier.getStep(STEP_IMPORT_SUB_SCHEMAS),
         userId
     );
+    toolsResult.tools = [...preResolvedTools, ...toolsResult.tools];
 
     for (const toolMapping of toolsMapping) {
         const toolByMessageId = toolsResult.tools.find(
-            // tslint:disable-next-line:no-shadowed-variable
-            (tool) => tool.messageId === toolMapping.messageId
+            (t) => t.messageId === toolMapping.messageId
         );
         toolMapping.newHash = toolByMessageId?.hash;
     }
@@ -508,6 +488,7 @@ export async function importToolByFile(
 
     // Replace id
     await replaceConfig(tool, schemasMap, toolsMapping);
+    await updateToolConfig(tool);
 
     const item = await DatabaseServer.createTool(tool);
     const _topicRow = await DatabaseServer.getTopicById(topic.topicId);

guardian-service/src/helpers/import-helpers/tool/tool-override-resolver.ts

@@ -0,0 +1,60 @@
+import { ModuleStatus, PolicyToolMetadata } from '@guardian/interfaces';
+import { DatabaseServer, PolicyTool } from '@guardian/common';
+import { ImportToolMap } from './tool-import.interface.js';
+
+/**
+ * Resolve user-provided tool messageId overrides against the local DB.
+ *
+ * For each tool whose messageId is remapped via `metadata.tools`, look up the
+ * target tool locally (status `PUBLISHED`). Pre-resolved tools are returned
+ * separately so callers can skip the IPFS round-trip in `importSubTools` —
+ * which would otherwise fail the strict hash/owner equality check inside
+ * `importToolByMessage` for tools the user has explicitly chosen.
+ */
+export async function resolveToolOverrides(
+    tools: PolicyTool[],
+    metadata: PolicyToolMetadata | null
+): Promise<{
+    toolsMapping: ImportToolMap[];
+    preResolvedTools: PolicyTool[];
+    toolsToImport: PolicyTool[];
+}> {
+    const toolsMapping: ImportToolMap[] = [];
+    const preResolvedTools: PolicyTool[] = [];
+    const toolsToImport: PolicyTool[] = [];
+    const overrides: { tool: PolicyTool, overrideMessageId: string }[] = [];
+
+    for (const tool of tools) {
+        const overrideMessageId = metadata?.tools?.[tool.messageId];
+        if (overrideMessageId && tool.messageId !== overrideMessageId) {
+            overrides.push({ tool, overrideMessageId });
+        } else {
+            toolsToImport.push(tool);
+        }
+    }
+
+    const localTools = overrides.length
+        ? await DatabaseServer.getTools({
+            messageId: { $in: overrides.map((o) => o.overrideMessageId) },
+            status: ModuleStatus.PUBLISHED
+        })
+        : [];
+    const localToolsByMessageId = new Map(localTools.map((t) => [t.messageId, t]));
+
+    for (const { tool, overrideMessageId } of overrides) {
+        toolsMapping.push({
+            oldMessageId: tool.messageId,
+            messageId: overrideMessageId,
+            oldHash: tool.hash,
+        });
+        const localTool = localToolsByMessageId.get(overrideMessageId);
+        if (localTool) {
+            preResolvedTools.push(localTool);
+        } else {
+            tool.messageId = overrideMessageId;
+            toolsToImport.push(tool);
+        }
+    }
+
+    return { toolsMapping, preResolvedTools, toolsToImport };
+}