fix(search): keep the dot-free name on a legacy reference-prefix collision

Creating or renaming a block enforces uniqueness at the normalized level, but
legacy workflows can still hold two names that collide only now that
`normalizeName` strips dots. `BlockResolver` settles that tie by letting the
dot-free name keep ownership of the key, so previously working references never
change targets.

The prefix map took whichever block was iterated last instead, so search could
name a reference after the dotted block while execution resolved it to the
dot-free one - search reporting the wrong block, which is what this is meant to
stop. Mirror the resolver's rule so both agree.

Author: icecrasher321

apps/sim/lib/workflows/search-replace/indexer.test.ts

@@ -202,6 +202,36 @@ describe('indexWorkflowSearchMatches', () => {
         matches.filter((match) => match.kind === 'environment').map((match) => match.searchText)
       ).toEqual(['OLD_SECRET', 'OLD_SECRET'])
     })
+
+    /**
+     * Legacy workflows can hold two names that collide only now that
+     * `normalizeName` strips dots. `BlockResolver` gives the key to the dot-free
+     * name whichever order the blocks arrive in, so search has to name the same
+     * block or it would label the reference with a title that block does not own
+     * at execution time.
+     */
+    it.each([
+      ['dotted first', ['Hunter.io 1', 'Hunterio 1']],
+      ['dot-free first', ['Hunterio 1', 'Hunter.io 1']],
+    ])('names a legacy dot collision after the dot-free block (%s)', (_order, names) => {
+      const workflow = createSearchReplaceWorkflowFixture()
+      workflow.blocks['knowledge-1'].name = names[0]
+      workflow.blocks['api-1'].name = names[1]
+      workflow.blocks['agent-1'].subBlocks.systemPrompt.value = 'Read <hunterio1.email>.'
+
+      const matches = indexWorkflowSearchMatches({
+        workflow,
+        mode: 'all',
+        includeResourceMatchesWithoutQuery: true,
+        blockConfigs: SEARCH_REPLACE_BLOCK_CONFIGS,
+      })
+
+      expect(
+        matches
+          .filter((match) => match.kind === 'workflow-reference')
+          .map((match) => match.searchText)
+      ).toEqual(['Hunterio 1.email'])
+    })
   })
 
   it('does not index internal row metadata in structured subblock values', () => {

apps/sim/lib/workflows/search-replace/resources/references.ts

@@ -72,8 +72,15 @@ export function parseInlineReferences(value: string): ParsedInlineReference[] {
  * Indexes a workflow's block names by the prefix their references carry, so a
  * parsed reference can be read back as the name the canvas shows.
  *
- * Block names are unique by normalized form, so a prefix identifies at most one
- * block. Blank names are skipped rather than mapped to an empty prefix.
+ * Creating or renaming a block enforces uniqueness at the normalized level, but
+ * legacy workflows can still hold two names that collide only now that
+ * `normalizeName` strips dots. `BlockResolver` settles that tie by letting the
+ * dot-free name keep ownership of the key, so previously working references
+ * never change targets; this mirrors that rule rather than taking whichever
+ * block happens to be iterated last, so search names the block a reference
+ * actually resolves to at execution time.
+ *
+ * Blank names are skipped rather than mapped to an empty prefix.
  */
 export function buildBlockNamesByReferencePrefix(
   blocks: Record<string, { name?: string }>
@@ -83,7 +90,12 @@ export function buildBlockNamesByReferencePrefix(
   for (const block of Object.values(blocks)) {
     if (typeof block.name !== 'string') continue
     const prefix = normalizeName(block.name)
-    if (prefix) namesByPrefix.set(prefix, block.name)
+    if (!prefix) continue
+
+    const incumbent = namesByPrefix.get(prefix)
+    if (incumbent === undefined || incumbent.includes(REFERENCE.PATH_DELIMITER)) {
+      namesByPrefix.set(prefix, block.name)
+    }
   }
 
   return namesByPrefix