refactor(hickey,lowy): derive NoteMatch.uri in ToJSON to remove redundant field

The uri field on NoteMatch was a derived value (noteUriPrefix <> path)
stored alongside its source, with the rule enforced only inside
noteMatchOf. Two consequences:

* The pure result type imported wire-layer concerns
  (Emanote.MCP.Uri + Catalog ResourceKind) for a field every consumer
  could derive.
* Two ways to drift: if noteUriPrefix ever changes, every site that
  reads NoteMatch.uri sees the stale value.

Drop uri from the record and emit it from the manual ToJSON instance.
Wire shape is unchanged (clients still receive uri); construction is
concentrated in one place. The test asserts on the JSON payload now
that the field no longer exists on the Haskell value.

Author: srid

emanote/src/Emanote/MCP/Tools.hs

@@ -1,5 +1,5 @@
-{-# LANGUAGE DeriveAnyClass #-}
 {-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE NamedFieldPuns #-}
 
 {- | MCP query tools (phase 3).
 
@@ -29,8 +29,7 @@ import Data.Aeson qualified as Aeson
 import Data.IxSet.Typed qualified as Ix
 import Data.Map.Strict qualified as Map
 import Data.Text qualified as T
-import Emanote.MCP.Catalog (ResourceKind (Note))
-import Emanote.MCP.Uri (kindToUri)
+import Emanote.MCP.Uri (noteUriPrefix)
 import Emanote.Model (Model)
 import Emanote.Model qualified as M
 import Emanote.Model.Graph qualified as G
@@ -73,35 +72,41 @@ tools readModel =
 data NoteMatch = NoteMatch
   { path :: Text
   , title :: Text
-  , uri :: Text
   }
   deriving stock (Eq, Show, Generic)
-  deriving anyclass (ToJSON)
+
+{- | The @uri@ field is derived from @path@ so there is no way for the two to
+diverge: drift in 'noteUriPrefix' propagates to every consumer through
+one place.
+-}
+instance ToJSON NoteMatch where
+  toJSON NoteMatch {path, title} =
+    Aeson.object
+      [ "path" .= path
+      , "title" .= title
+      , "uri" .= (noteUriPrefix <> path)
+      ]
 
 noteMatchOf :: N.Note -> NoteMatch
 noteMatchOf note =
-  let p = toText $ R.lmlSourcePath (note ^. N.noteRoute)
-   in NoteMatch
-        { path = p
-        , title = Tit.toPlain (note ^. N.noteTitle)
-        , uri = kindToUri (Note (toString p))
-        }
+  NoteMatch
+    { path = toText $ R.lmlSourcePath (note ^. N.noteRoute)
+    , title = Tit.toPlain (note ^. N.noteTitle)
+    }
 
 {- | Build a 'NoteMatch' from a route. Falls back to a route-derived title
 when the note can't be looked up — used by callers that hold a route but
 not the 'N.Note' (e.g. backlink sources).
 -}
 noteMatchOfRoute :: Model -> R.LMLRoute -> NoteMatch
 noteMatchOfRoute model r =
-  case M.modelLookupNoteByRoute' r model of
-    Just note -> noteMatchOf note
-    Nothing ->
-      let p = toText $ R.lmlSourcePath r
-       in NoteMatch
-            { path = p
-            , title = Tit.toPlain (Tit.fromRoute r)
-            , uri = kindToUri (Note (toString p))
-            }
+  maybe fallback noteMatchOf (M.modelLookupNoteByRoute' r model)
+  where
+    fallback =
+      NoteMatch
+        { path = toText $ R.lmlSourcePath r
+        , title = Tit.toPlain (Tit.fromRoute r)
+        }
 
 -- ---------------------------------------------------------------------------
 -- find_notes

emanote/test/Emanote/MCP/ToolsSpec.hs

@@ -1,5 +1,7 @@
 module Emanote.MCP.ToolsSpec where
 
+import Data.Aeson qualified as Aeson
+import Data.Text qualified
 import Emanote.MCP.Tools (NoteMatch (..), ResolveResult (..), findNotes, getBacklinks, resolveWikilink)
 import Emanote.Model.Note qualified as MN
 import Emanote.Model.Type qualified as M
@@ -57,9 +59,10 @@ spec = do
     it "treats a non-positive limit as zero" $ do
       findNotes "guide" 0 notebook `shouldBe` []
 
-    it "advertises an emanote:// URI for every match" $ do
+    it "advertises an emanote:// URI for every match in the JSON payload" $ do
       let [hit] = findNotes "wiki" 20 notebook
-      uri hit `shouldBe` "emanote://note/guide/wikilinks.md"
+          json = decodeUtf8 @Text (Aeson.encode hit)
+      json `shouldSatisfy` Data.Text.isInfixOf "\"uri\":\"emanote://note/guide/wikilinks.md\""
 
   describe "getBacklinks" $ do
     let target = LMLRoute_Md (R ("guide" :| ["neuron"]))