fix(lint): resolve E305 module naming convention across packages

Rename CamelCase internal modules to Snake_case per OCaml convention:
- ocaml-hap: TlvType→Tlv_type, HapError→Hap_error, CharType→Char_type
- ocaml-cookeio: SameSite→Same_site, DateParser→Date_parser
- ocaml-claudeio: PreToolUse→Pre_tool_use, PostToolUse→Post_tool_use,
UserPromptSubmit→User_prompt_submit, SubagentStop→Subagent_stop,
PreCompact→Pre_compact (wire format strings preserved)
- irmin: StringMap→String_map, PathSet→Path_set
- ocaml-block: ReadOnly→Read_only, WithCrc→With_crc

lib/backend.ml

···
 type stats = { reads : int; writes : int; cache_hits : int; cache_misses : int }
 
 module Memory = struct
-  module StringMap = Map.Make (String)
+  module String_map = Map.Make (String)
 
   type 'hash state = {
-    mutable objects : string StringMap.t;
-    mutable refs : 'hash StringMap.t;
+    mutable objects : string String_map.t;
+    mutable refs : 'hash String_map.t;
     to_hex : 'hash -> string;
     equal : 'hash -> 'hash -> bool;
   }
···
   let create_with_hash (type h) (to_hex : h -> string) (equal : h -> h -> bool)
       : h t =
     let state =
-      { objects = StringMap.empty; refs = StringMap.empty; to_hex; equal }
+      { objects = String_map.empty; refs = String_map.empty; to_hex; equal }
     in
     {
       read =
         (fun h ->
           let key = state.to_hex h in
-          StringMap.find_opt key state.objects);
+          String_map.find_opt key state.objects);
       write =
         (fun h data ->
           let key = state.to_hex h in
-          state.objects <- StringMap.add key data state.objects);
+          state.objects <- String_map.add key data state.objects);
       exists =
         (fun h ->
           let key = state.to_hex h in
-          StringMap.mem key state.objects);
-      get_ref = (fun name -> StringMap.find_opt name state.refs);
+          String_map.mem key state.objects);
+      get_ref = (fun name -> String_map.find_opt name state.refs);
       set_ref =
-        (fun name hash -> state.refs <- StringMap.add name hash state.refs);
+        (fun name hash -> state.refs <- String_map.add name hash state.refs);
       test_and_set_ref =
         (fun name ~test ~set ->
-          let current = StringMap.find_opt name state.refs in
+          let current = String_map.find_opt name state.refs in
           let matches =
             match (test, current) with
             | None, None -> true
···
           in
           if matches then (
             (match set with
-            | None -> state.refs <- StringMap.remove name state.refs
-            | Some h -> state.refs <- StringMap.add name h state.refs);
+            | None -> state.refs <- String_map.remove name state.refs
+            | Some h -> state.refs <- String_map.add name h state.refs);
             true)
           else false);
-      list_refs = (fun () -> StringMap.bindings state.refs |> List.map fst);
+      list_refs = (fun () -> String_map.bindings state.refs |> List.map fst);
       write_batch =
         (fun objects ->
           List.iter
             (fun (h, data) ->
               let key = state.to_hex h in
-              state.objects <- StringMap.add key data state.objects)
+              state.objects <- String_map.add key data state.objects)
             objects);
       flush = (fun () -> ());
       close = (fun () -> ());
···
 
     Inspired by lavyek's append-only design and LevelDB's WAL pattern. *)
 module Disk = struct
-  module StringMap = Map.Make (String)
+  module String_map = Map.Make (String)
 
   type index_entry = { offset : int; length : int }
 
···
     mutable wal : Wal.t option;
     mutable data_file : Eio.File.rw_ty Eio.Resource.t option;
     mutable data_offset : int;
-    mutable index : index_entry StringMap.t;
+    mutable index : index_entry String_map.t;
     bloom : string Bloom.t;
-    mutable refs : 'hash StringMap.t;
+    mutable refs : 'hash String_map.t;
     to_hex : 'hash -> string;
     equal : 'hash -> 'hash -> bool;
     mutex : Eio.Mutex.t;
···
                | [ hex; off_s; len_s ] ->
                    let offset = int_of_string off_s in
                    let length = int_of_string len_s in
-                   StringMap.add hex { offset; length } idx
+                   String_map.add hex { offset; length } idx
                | _ -> idx)
-           StringMap.empty
-    else StringMap.empty
+           String_map.empty
+    else String_map.empty
 
   let save_index root index =
     let path = index_path root in
     let tmp_path = Eio.Path.(root / "objects.idx.tmp") in
     let content =
-      StringMap.fold
+      String_map.fold
         (fun hex entry acc ->
           Printf.sprintf "%s %d %d\n" hex entry.offset entry.length :: acc)
         index []
···
   let load_ref of_hex acc full_name entry_path =
     let hex = String.trim (Eio.Path.load entry_path) in
     match of_hex hex with
-    | Ok hash -> StringMap.add full_name hash acc
+    | Ok hash -> String_map.add full_name hash acc
     | Error _ -> acc
 
   let load_refs root of_hex =
     let refs_root = refs_path root in
-    if not (Eio.Path.is_directory refs_root) then StringMap.empty
+    if not (Eio.Path.is_directory refs_root) then String_map.empty
     else
       let rec scan_dir prefix path acc =
         let entries = Eio.Path.read_dir path in
···
             else acc)
           acc entries
       in
-      scan_dir "" refs_root StringMap.empty
+      scan_dir "" refs_root String_map.empty
 
   let save_ref root name hash to_hex =
     let path = refs_path root in
···
           match decode_wal_record record with
           | None -> (idx, blm, offset)
           | Some (hex, data) ->
-              if StringMap.mem hex idx then (idx, blm, offset)
+              if String_map.mem hex idx then (idx, blm, offset)
               else begin
                 (* Write to data file *)
                 let len = String.length data in
                 Eio.File.pwrite_all data_file
                   ~file_offset:(Optint.Int63.of_int offset)
                   [ Cstruct.of_string data ];
-                let idx' = StringMap.add hex { offset; length = len } idx in
+                let idx' = String_map.add hex { offset; length = len } idx in
                 Bloom.add blm hex;
                 (idx', blm, offset + len)
               end)
···
     let bloom = load_bloom root in
     (* Populate bloom from index if empty (first load after upgrade) *)
     if Bloom.size_estimate bloom = 0 then
-      StringMap.iter (fun hex _ -> Bloom.add bloom hex) index;
+      String_map.iter (fun hex _ -> Bloom.add bloom hex) index;
     let refs = load_refs root of_hex in
     let file, offset = open_data_file ~sw root in
     let data_file = (file :> Eio.File.rw_ty Eio.Resource.t) in
···
       read =
         (fun h ->
           let key = state.to_hex h in
-          match StringMap.find_opt key state.index with
+          match String_map.find_opt key state.index with
           | None -> None
           | Some entry -> (
               match state.data_file with
···
           Eio.Mutex.use_rw ~protect:true state.mutex (fun () ->
               let key = state.to_hex h in
               (* Fast path: bloom filter says "definitely not present" *)
-              if Bloom.mem state.bloom key && StringMap.mem key state.index then
-                ()
+              if Bloom.mem state.bloom key && String_map.mem key state.index
+              then ()
               else
                 match (state.wal, state.data_file) with
                 | Some wal, Some file ->
···
                       [ Cstruct.of_string data ];
                     state.data_offset <- offset + len;
                     state.index <-
-                      StringMap.add key { offset; length = len } state.index;
+                      String_map.add key { offset; length = len } state.index;
                     Bloom.add state.bloom key
                 | _ -> ()));
       exists =
         (fun h ->
           let key = state.to_hex h in
           (* Fast path: bloom filter for negative lookups *)
-          Bloom.mem state.bloom key && StringMap.mem key state.index);
-      get_ref = (fun name -> StringMap.find_opt name state.refs);
+          Bloom.mem state.bloom key && String_map.mem key state.index);
+      get_ref = (fun name -> String_map.find_opt name state.refs);
       set_ref =
         (fun name hash ->
           Eio.Mutex.use_rw ~protect:true state.mutex (fun () ->
-              state.refs <- StringMap.add name hash state.refs;
+              state.refs <- String_map.add name hash state.refs;
               save_ref state.root name hash state.to_hex));
       test_and_set_ref =
         (fun name ~test ~set ->
           Eio.Mutex.use_rw ~protect:true state.mutex (fun () ->
-              let current = StringMap.find_opt name state.refs in
+              let current = String_map.find_opt name state.refs in
               let matches =
                 match (test, current) with
                 | None, None -> true
···
               if matches then begin
                 (match set with
                 | None ->
-                    state.refs <- StringMap.remove name state.refs;
+                    state.refs <- String_map.remove name state.refs;
                     delete_ref state.root name
                 | Some h ->
-                    state.refs <- StringMap.add name h state.refs;
+                    state.refs <- String_map.add name h state.refs;
                     save_ref state.root name h state.to_hex);
                 true
               end
               else false));
-      list_refs = (fun () -> StringMap.bindings state.refs |> List.map fst);
+      list_refs = (fun () -> String_map.bindings state.refs |> List.map fst);
       write_batch =
         (fun objects ->
           Eio.Mutex.use_rw ~protect:true state.mutex (fun () ->
···
                   List.iter
                     (fun (h, data) ->
                       let key = state.to_hex h in
-                      if not (StringMap.mem key state.index) then
+                      if not (String_map.mem key state.index) then
                         Wal.append wal (encode_wal_record key data))
                     objects;
                   Wal.sync wal;
···
                   List.iter
                     (fun (h, data) ->
                       let key = state.to_hex h in
-                      if StringMap.mem key state.index then ()
+                      if String_map.mem key state.index then ()
                       else begin
                         let len = String.length data in
                         let offset = state.data_offset in
···
                           [ Cstruct.of_string data ];
                         state.data_offset <- offset + len;
                         state.index <-
-                          StringMap.add key { offset; length = len } state.index;
+                          String_map.add key { offset; length = len }
+                            state.index;
                         Bloom.add state.bloom key
                       end)
                     objects

lib/proof.ml

···
   type contents = string
 
   (* Path set for tracking accessed paths *)
-  module PathSet = Set.Make (struct
+  module Path_set = Set.Make (struct
     type t = string list
 
     let compare = compare
···
     | Producing of {
         backend : hash Backend.t;
         node_hash : hash;
-        mutable accessed : PathSet.t;
+        mutable accessed : Path_set.t;
       }
     | From_proof of { tree : (hash, contents) tree }
 
···
     type t = { state : tree_state }
 
     let of_hash backend h =
-      { state = Producing { backend; node_hash = h; accessed = PathSet.empty } }
+      {
+        state = Producing { backend; node_hash = h; accessed = Path_set.empty };
+      }
 
     let of_proof_tree tree = { state = From_proof { tree } }
 
···
     (* Record access to a path *)
     let record_access t path =
       match t.state with
-      | Producing p -> p.accessed <- PathSet.add path p.accessed
+      | Producing p -> p.accessed <- Path_set.add path p.accessed
       | From_proof _ -> ()
 
     (* Navigate to a path in a backend-stored node *)
···
   let build_proof_tree backend node_hash accessed =
     let rec build node prefix =
       let dominated_by_access =
-        PathSet.exists
+        Path_set.exists
           (fun path ->
             let plen = List.length prefix in
             List.length path >= plen
···
               let child_tree =
                 match kind with
                 | `Contents h ->
-                    if PathSet.mem child_path accessed then
+                    if Path_set.mem child_path accessed then
                       match backend.Backend.read h with
                       | Some c -> Contents c
                       | None -> Blinded_contents h
                     else Blinded_contents h
                 | `Node h ->
                     if
-                      PathSet.exists
+                      Path_set.exists
                         (fun p ->
                           let clen = List.length child_path in
                           List.length p >= clen
···
     let accessed =
       match tree.state with
       | Producing { accessed; _ } -> accessed
-      | From_proof _ -> PathSet.empty
+      | From_proof _ -> Path_set.empty
     in
     let proof_tree = build_proof_tree backend root_hash accessed in
     let proof =

lib/proof.mli

···
     (** Proof-aware tree that records accesses during [produce]. *)
 
     val find : t -> string list -> contents option
+    (** [find t path] returns the contents at [path], or [None] if not found. *)
+
     val find_tree : t -> string list -> t option
+    (** [find_tree t path] returns the subtree at [path], or [None] if not
+        found. *)
+
     val mem : t -> string list -> bool
+    (** [mem t path] checks whether a value exists at [path]. *)
+
     val list : t -> string list -> (string * [ `Node | `Contents ]) list
+    (** [list t path] returns the children of [path], each tagged as either a
+        node or contents. *)
+
     val add : t -> string list -> contents -> t
+    (** [add t path contents] returns a new tree with contents added or updated
+        at [path]. *)
+
     val add_tree : t -> string list -> t -> t
+    (** [add_tree t path subtree] returns a new tree with [subtree] grafted at
+        [path]. *)
+
     val remove : t -> string list -> t
+    (** [remove t path] returns a new tree with the value at [path] removed. *)
+
     val hash : t -> hash
+    (** [hash t] computes the root hash of the tree. *)
   end
 
   val produce :