@@ -795,7 +795,14 @@ const CLOUD_PROVIDERS: readonly CloudProviderName[] = ['icloud', 'onedrive', 'dr
 const CLOUD_ID: Record<string, number> = { icloud: 1, onedrive: 2, dropbox: 3 };
 
 const utf8Encoder = new TextEncoder();
-const utf8Decoder = new TextDecoder();
+/**
+ * Reads a stored name back byte for byte. `ignoreBOM`: a name may begin with
+ * U+FEFF — fs.readdir keeps it, and the encoder stores its three bytes — and
+ * a decoder made without it reads them as nothing, so '\uFEFFfoo' was spelled
+ * as the 'foo' beside it and '\uFEFF' alone as its folder (CI4 review F2.1,
+ * F2.2): a path that names another file, which a delete would act on.
+ */
+const utf8Decoder = new TextDecoder('utf-8', { ignoreBOM: true });
 
 const INITIAL_CAP = 1024;
 const INITIAL_POOL = 16 * 1024;
@@ -1509,20 +1516,12 @@ export class PackedScanStore implements ScanStore {
     } else {
       const from = this.nameOff[parent];
       const to = this.nameOff[parent + 1];
-      const bytes = this.nameBytes;
-      if (to - from >= 3 && bytes[from] === 0xef && bytes[from + 1] === 0xbb && bytes[from + 2] === 0xbf) {
-        // A leading byte-order mark, which name()'s TextDecoder reads as
-        // nothing (CI4 review F1.1): '\uFEFF' alone is the empty name though
-        // its three bytes are stored, and '\uFEFF/' is the separator alone.
-        // Decided from the parent's name as name() reads it — its name, never
-        // its path.
-        const parentName = this.name(parent);
-        endsWithSep = parentName.length === 0 || parentName.endsWith(this.sep);
-      } else {
-        // The parent's stored name is empty or ends in the separator's byte
-        // (UTF-8: an ASCII byte is never part of a longer character).
-        endsWithSep = to === from || bytes[to - 1] === this.sepByte;
-      }
+      // The parent's stored name is empty or ends in the separator's byte
+      // (UTF-8: an ASCII byte is never part of a longer character). name()
+      // reads every stored byte back, a leading byte-order mark's too (CI4
+      // review F2.1, F2.2), so the name is empty, or ends with the separator,
+      // exactly when its bytes do.
+      endsWithSep = to === from || this.nameBytes[to - 1] === this.sepByte;
     }
     return endsWithSep ? parentPath + name : parentPath + this.sep + name;
   }
 
@@ -164,10 +164,10 @@ test('CI4: childPath answers byte for byte what reading its parent path answered
   for (const [rootPath, sep] of roots) {
     // '' after 'a': an empty name's stored bytes sit after a name that does
     // not end in the separator, so only its emptiness can say it does.
-    // A byte-order mark (CI4 review F1.1): name() reads a leading one as
-    // nothing, so '\uFEFF' alone is the empty name though three bytes are
-    // stored, and '\uFEFF' + sep is the separator alone; one anywhere else,
-    // or a second, is part of the name.
+    // A byte-order mark (CI4 review F1.1, F2.1/F2.2): name() reads one back
+    // as it was stored, a leading one too, so '\uFEFF' alone is a name of one
+    // character that does not end in the separator, and '\uFEFF' + sep one
+    // that does.
     const names = ['a', '', `a${sep}`, 'é', `é${sep}`, 'b\\', 'c/', `${sep}${sep}`, ':', 'b:', 'z::', 'Ʀ', '\uFEFF', `\uFEFF${sep}`, 'a\uFEFF', '\uFEFF\uFEFF'];
     const packed = new PackedScanStore(rootPath, sep, folderInput('r'));
     // Every name under the root, under every name, under every name: a parent
@@ -203,6 +203,66 @@ test('CI4: childPath answers byte for byte what reading its parent path answered
   }
 });
 
+test('CI4 review F2.1/F2.2: a name that begins with a byte-order mark keeps it — "\\uFEFFfoo" beside "foo", and "\\uFEFF" alone, are each spelled as the file they name, by name(), path(), childPath(), the path lookup and the scan JSON, as the object store spells them', async () => {
+  // A walker lists a folder with fs.readdir, whose names keep a leading
+  // U+FEFF, and the store keeps its three bytes (EF BB BF). A TextDecoder
+  // made without ignoreBOM reads them as nothing, so the 900-byte
+  // '\uFEFFfoo' was spelled '/data/foo' — the 5-byte 'foo' beside it — and a
+  // file named '\uFEFF' alone was spelled as its folder. A path is what a
+  // delete acts on: one node, its own spelling.
+  const BOM = '\uFEFF';
+  interface Listed { name: string; size?: number; children?: Listed[] }
+  // Siblings that a decoder dropping the mark spells alike: 'foo' and
+  // '\uFEFFfoo'; '\uFEFF' and its folder; '\uFEFFsub/a' and 'sub/a'; and a
+  // folder named '\uFEFF' alone with a file in it.
+  const listing: Listed[] = [
+    { name: 'foo', size: 5 },
+    { name: `${BOM}foo`, size: 900 },
+    { name: BOM, size: 7 },
+    { name: `${BOM}sub`, children: [{ name: 'a', size: 11 }, { name: BOM, size: 13 }] },
+    { name: 'sub', children: [{ name: 'a', size: 17 }, { name: BOM, children: [{ name: 'b', size: 19 }] }] },
+  ];
+  const input = (l: Listed): NodeInput => ({ name: l.name, isDir: l.children !== undefined, size: l.size ?? 0, modifiedAt: 1, isHidden: false });
+  for (const [rootPath, sep] of [['/data', '/'], ['C:\\data', '\\']] as const) {
+    const stores = [new ObjectScanStore(rootPath, sep, folderInput('data')), new PackedScanStore(rootPath, sep, folderInput('data'))];
+    for (const store of stores) {
+      const build = (parent: number, list: Listed[]): void => {
+        for (const l of list) {
+          const id = store.addNode(parent, input(l));
+          if (l.children) build(id, l.children);
+        }
+      };
+      build(store.rootId, listing);
+      store.finalize();
+      store.sumSizes();
+    }
+    for (const store of stores) {
+      // Walked from the root by the store's own child lists, in the order they
+      // were listed: a packed store numbers its nodes anew when it finalizes.
+      const label = `${rootPath} on the ${store.constructor.name}`;
+      const stack: Array<{ id: number; path: string; list: Listed[] }> = [{ id: store.rootId, path: rootPath, list: listing }];
+      while (stack.length > 0) {
+        const { id, path: parentPath, list } = stack.pop() as { id: number; path: string; list: Listed[] };
+        const kids = store.childIds(id);
+        assert.equal(kids.length, list.length, `${label}: ${JSON.stringify(parentPath)} holds what was listed in it`);
+        kids.forEach((kid, i) => {
+          const { name, children } = list[i];
+          const path = `${parentPath}${sep}${name}`;
+          assert.equal(store.name(kid), name, `${label}: the name ${JSON.stringify(name)} as it was listed`);
+          assert.equal(store.path(kid), path, `${label}: path() of ${JSON.stringify(path)}`);
+          assert.equal(store.childPath(kid, store.path(id)), path, `${label}: childPath() of ${JSON.stringify(path)}`);
+          // A lookup answers one node for a path: each node's finding itself is
+          // every path being its own.
+          assert.equal(store.findByPath(store.path(kid)), kid, `${label}: path() of ${JSON.stringify(path)} finds that node, not another`);
+          if (children) stack.push({ id: kid, path, list: children });
+        });
+      }
+    }
+    const [obj, packed] = stores;
+    assert.equal((await streamed(packed, 13)).json, wholeTreeJson(obj), `${rootPath}: the packed store's scan JSON is the object store's`);
+  }
+});
+
 test('eviction semantics: dropping the store frees it for GC (no registry leaks)', () => {
   // The store keeps no module-level registries — everything is instance state,
   // so dropping the last reference is sufficient for GC. This guards against
 
@@ -442,3 +442,26 @@ test('CI4 review F1.2: a sort tie that reads a kept folder\'s path while its fil
   assert.equal(probes, 1, 'the deepest folder\'s path is built once, for its tie');
   assert.ok(held < HELD_PER_FOLDER * DEPTH, heldMessage('type:dir', held, DEPTH, keptPath));
 });
+
+test('CI4 review F2.1/F2.2: a hit whose name begins with a byte-order mark keeps it — "\\uFEFFfoo" beside "foo", and "\\uFEFF" alone, are answered as the files they are, each under its own path', async () => {
+  // A hit's path is what DELETE /api/files, the cart and an Autopilot query
+  // policy act on. Read without its mark, the 900-byte '\uFEFFfoo' was
+  // answered as '/data/foo', the 5-byte file beside it, and the 7-byte
+  // '\uFEFF' as '/data/', its folder. The oracle is the listing the store was
+  // built from, as a walker's fs.readdir gives the names.
+  const BOM = '\uFEFF';
+  const file = (dir: string, name: string, size: number): FileNode => ({ name, path: `${dir}/${name}`, type: 'file', extension: '', size, modifiedAt: T - YEAR, isHidden: false });
+  const sub = `/data/${BOM}sub`;
+  const listed = [file('/data', 'foo', 5), file('/data', `${BOM}foo`, 900), file('/data', BOM, 7), file(sub, BOM, 13), file(sub, 'foo', 11)];
+  const tree: FileNode = {
+    name: 'data', path: '/data', type: 'dir', size: 936, modifiedAt: T - YEAR, isHidden: false,
+    children: [...listed.slice(0, 3), { name: `${BOM}sub`, path: sub, type: 'dir', size: 24, modifiedAt: T - YEAR, isHidden: false, children: listed.slice(3) }],
+  };
+  const out = await run(scanOf(tree), 'type:file');
+  const bySize = (a: { size: number }, b: { size: number }): number => a.size - b.size;
+  assert.deepEqual(
+    out.hits.map((h) => ({ path: h.path, name: h.name, size: h.size })).sort(bySize),
+    listed.map((n) => ({ path: n.path, name: n.name, size: n.size })).sort(bySize),
+    'every file answered under its own name and path',
+  );
+});