Tighten Look-alikes, rework Similar sets into named albums, plain-language UI

Look-alikes: drop the feature-print threshold 0.7 → 0.15. Apple-certified
identical images measure 0.0; merely-similar shots (three cat poses ≈0.23–0.35)
were sailing under 0.7 and getting pre-marked for deletion. 0.15 catches only
true re-saved copies and leaves the similar-but-different ones alone.

Similar sets: no longer broad category buckets. It now clusters the library at
the "same scene, different moment" band (dHash ≤14 candidates, feature distance
≤0.45 — so the cats group here, not in Look-alikes) and turns each set into a
named album. Names come from the set's Vision content tags, prettified by apfel
(Apple Intelligence CLI) when available, else the top tag. No deletion.

UI text rewritten in plain, everyday language across en/ja/zh-TW — onboarding
captions, the two section headers (Near-identical / A bit alike — you choose),
keep/delete/favorite tooltips, and the Apple-ranked / Faces hints.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: chodaict

app/Sources/SnapsiftApp/Apfel.swift

@@ -23,7 +23,7 @@ enum Apfel {
     /// Labels (a subset of `labels`) whose meaning matches `query`, or nil if
     /// apfel can't run (caller should fall back to substring matching).
     static func match(query: String, labels: [String]) async -> [String]? {
-        guard let url else { return nil }
+        guard isInstalled else { return nil }
         let system = """
             You map a photo-search query to category labels. Given a QUERY and a \
             list of LABELS (lowercase taxonomy ids), reply with ONLY a JSON array \
@@ -42,6 +42,23 @@ enum Apfel {
         return matched.isEmpty ? nil : matched
     }
 
+    /// A short, friendly album name for a set of photos described by Vision tags
+    /// (e.g. ["cat","basket","indoor"] → "Cat in a basket"). nil if apfel can't
+    /// run — caller falls back to the top tag.
+    static func albumName(tags: [String]) async -> String? {
+        guard url != nil, !tags.isEmpty else { return nil }
+        let system = """
+            You name a photo album in 2–4 words from content tags. Reply with ONLY \
+            the name — no quotes, no punctuation, Title Case. Be natural, not a tag list.
+            """
+        let prompt = "TAGS: \(tags.joined(separator: ", "))"
+        guard let out = await run(["-q", "--temperature", "0.3", "-s", system, prompt]) else { return nil }
+        let name = out.trimmingCharacters(in: .whitespacesAndNewlines)
+            .replacingOccurrences(of: "\"", with: "")
+        let firstLine = name.split(whereSeparator: \.isNewline).first.map(String.init) ?? name
+        return firstLine.isEmpty || firstLine.count > 40 ? nil : firstLine
+    }
+
     private static func run(_ args: [String]) async -> String? {
         guard let url else { return nil }
         return await withCheckedContinuation { cont in

app/Sources/SnapsiftApp/CategoryScanner.swift

@@ -18,15 +18,19 @@ enum CategoryScanner {
 
     /// The chosen bucket label for an asset, or nil if nothing is reliable.
     static func category(for asset: PHAsset, manager: PHCachingImageManager) async -> String? {
-        guard let cg = await cgImage(for: asset, manager: manager) else { return nil }
+        await labels(for: asset, manager: manager).first
+    }
+
+    /// Up to `limit` reliable, specific content labels for an asset (most
+    /// specific first; over-generic ancestors dropped). Used to name a set.
+    static func labels(for asset: PHAsset, manager: PHCachingImageManager, limit: Int = 3) async -> [String] {
+        guard let cg = await cgImage(for: asset, manager: manager) else { return [] }
         let request = VNClassifyImageRequest()
         let handler = VNImageRequestHandler(cgImage: cg, options: [:])
-        do { try handler.perform([request]) } catch { return nil }
-        let reliable = (request.results ?? []).filter { $0.hasMinimumPrecision(0.3, forRecall: 0) }
-        if let specific = reliable.first(where: { !generic.contains($0.identifier) }) {
-            return specific.identifier
-        }
-        return reliable.first?.identifier
+        do { try handler.perform([request]) } catch { return [] }
+        let reliable = (request.results ?? [])
+            .filter { $0.hasMinimumPrecision(0.3, forRecall: 0) && !generic.contains($0.identifier) }
+        return Array(reliable.prefix(limit).map(\.identifier))
     }
 
     /// A label like "interior_room" → "Interior room" for display.

app/Sources/SnapsiftApp/L10n.swift

@@ -53,9 +53,9 @@ struct L10n: Sendable {
     }
     func tipSimilarSets() -> String {
         switch language {
-        case .en: return "Group your whole library by what's in each photo (neural, on-device) — across time, nothing deleted"
-        case .ja: return "写真の内容でライブラリ全体を分類（オンデバイス・時間をまたぐ・削除しない）"
-        case .zhTW: return "用照片內容把整個圖庫分類（裝置端神經、跨時間、不刪任何東西）"
+        case .en: return "Gathers the sets where you took several shots of the same thing into named albums — nothing deleted"
+        case .ja: return "同じ被写体を何枚も撮ったセットを、名前付きアルバムにまとめる（削除しない）"
+        case .zhTW: return "把你對同一個東西拍了好幾張的成組，整理成有名字的相簿（不刪任何東西）"
         }
     }
     func progClassifying(_ i: Int, _ total: Int) -> String {
@@ -65,6 +65,13 @@ struct L10n: Sendable {
         case .zhTW: return "分類中 \(i)/\(total)…"
         }
     }
+    func progNaming(_ i: Int, _ total: Int) -> String {
+        switch language {
+        case .en: return "Naming sets \(i)/\(total)…"
+        case .ja: return "セットに名前を付け中 \(i)/\(total)…"
+        case .zhTW: return "為相簿命名 \(i)/\(total)…"
+        }
+    }
     func categoryHeader(count: Int, shown: Int) -> String {
         switch language {
         case .en: return shown < count ? "\(count) photos · showing first \(shown)" : "\(count) photos"
@@ -138,9 +145,9 @@ struct L10n: Sendable {
     }
     func appleRanked() -> String {
         switch language {
-        case .en: return "Apple-ranked"
-        case .ja: return "Apple 品質順"
-        case .zhTW: return "Apple 品質排序"
+        case .en: return "Apple picked the best"
+        case .ja: return "Apple がベストを選択"
+        case .zhTW: return "Apple 幫你挑最好的"
         }
     }
     func selectCluster() -> String {
@@ -152,9 +159,9 @@ struct L10n: Sendable {
     }
     func scanHint() -> String {
         switch language {
-        case .en: return "Scan to find near-duplicate bursts"
-        case .ja: return "スキャンしてよく似た連写を探します"
-        case .zhTW: return "掃描以找出近乎重複的連拍"
+        case .en: return "Pick what to look for"
+        case .ja: return "何を探すか選んでください"
+        case .zhTW: return "選一個你想找的"
         }
     }
 
@@ -176,44 +183,44 @@ struct L10n: Sendable {
     }
     func tipKeeper() -> String {
         switch language {
-        case .en: return "Keeper"
-        case .ja: return "残す1枚"
-        case .zhTW: return "保留這張"
+        case .en: return "The one we'll keep"
+        case .ja: return "残すのはこの1枚"
+        case .zhTW: return "會留下的就這張"
         }
     }
     func tipDelete() -> String {
         switch language {
-        case .en: return "Will be deleted · click to keep this one"
-        case .ja: return "削除されます · クリックでこれを残す"
-        case .zhTW: return "將被刪除 · 點擊改留這張"
+        case .en: return "This one gets deleted — click it to keep it instead"
+        case .ja: return "これは削除されます — クリックすれば残せます"
+        case .zhTW: return "這張會被刪 — 點一下改成留它"
         }
     }
     func tipFavorite() -> String {
         switch language {
-        case .en: return "Favorite — always kept"
-        case .ja: return "お気に入り — 常に残します"
-        case .zhTW: return "最愛 — 一律保留"
+        case .en: return "Favorite — never deleted"
+        case .ja: return "お気に入り — 絶対に削除しません"
+        case .zhTW: return "最愛 — 絕對不刪"
         }
     }
     func tipScan() -> String {
         switch language {
-        case .en: return "Find near-duplicate burst sequences"
-        case .ja: return "よく似た連写を探す"
-        case .zhTW: return "找出近乎重複的連拍序列"
+        case .en: return "Clears the burst of near-identical shots from holding the shutter — keeps the best one"
+        case .ja: return "シャッターを押し続けて撮れたそっくりな連写を片付け、ベストの1枚を残す"
+        case .zhTW: return "把你按住快門連拍出的一堆幾乎一樣的，留最好一張、清掉其餘"
         }
     }
     func tipLookAlikes() -> String {
         switch language {
-        case .en: return "Find the same photo saved across different days (neural, on-device)"
-        case .ja: return "別の日に保存された同じ写真を探す（オンデバイスのニューラル解析）"
-        case .zhTW: return "找出不同天存下的同一張照片（裝置端神經分析）"
+        case .en: return "Finds the same photo saved more than once — re-downloaded, screenshotted, AirDropped back — even days apart"
+        case .ja: return "同じ写真を何度も保存したもの（再ダウンロード・スクショ・AirDrop）を、別の日でも見つける"
+        case .zhTW: return "找出同一張被存了好幾份的（重新下載、截圖、AirDrop 回來），就算隔了好幾天"
         }
     }
     func tipFaces() -> String {
         switch language {
-        case .en: return "Re-pick keepers using on-device face + open-eyes analysis"
-        case .ja: return "顔と開いた目の解析で残す1枚を選び直す（オンデバイス）"
-        case .zhTW: return "用裝置端人臉與睜眼分析重新挑選保留張"
+        case .en: return "Re-picks the keeper to the frame where faces look best — eyes open"
+        case .ja: return "顔がいちばん良く写った1枚（目が開いている）を残すよう選び直す"
+        case .zhTW: return "改挑大家臉拍得最好、眼睛有張開的那張當保留"
         }
     }
     func tipAppleRanked() -> String {
@@ -284,16 +291,16 @@ struct L10n: Sendable {
     }
     func sectionConfident(_ n: Int) -> String {
         switch language {
-        case .en: return "Duplicates · \(n)"
-        case .ja: return "重複 · \(n)"
-        case .zhTW: return "確定重複 · \(n)"
+        case .en: return "Near-identical · \(n)"
+        case .ja: return "ほぼ同じ · \(n)"
+        case .zhTW: return "幾乎一樣 · \(n)"
         }
     }
     func sectionPending(_ n: Int) -> String {
         switch language {
-        case .en: return "Similar — you decide · \(n)"
-        case .ja: return "似ている — あなたが選ぶ · \(n)"
-        case .zhTW: return "相似 · 你決定 · \(n)"
+        case .en: return "A bit alike — you choose · \(n)"
+        case .ja: return "少し似ている — あなたが選ぶ · \(n)"
+        case .zhTW: return "有點像 · 你決定 · \(n)"
         }
     }
     func keepAll() -> String {

app/Sources/SnapsiftApp/LibraryModel.swift

@@ -30,10 +30,10 @@ struct ReviewGroup: Identifiable {
 /// the same content label, across the whole library and across time.
 struct CategoryBucket: Identifiable {
     let id = UUID()
-    let label: String
+    let label: String      // already a display-ready name (apfel or top Vision tag)
     let photos: [Photo]
     var count: Int { photos.count }
-    var display: String { CategoryScanner.displayName(label) }
+    var display: String { label }
 }
 
 /// Drives the whole app: PhotoKit authorization, enumeration → Core clustering,
@@ -254,9 +254,11 @@ final class LibraryModel: ObservableObject {
         }
     }
 
-    /// "Similar sets": classify the whole library on-device (Vision) and bucket
-    /// photos by what's in them — across time, no deletion. Heavier than the
-    /// other passes (one classification per photo); shows progress.
+    /// "Similar sets": find sets of photos you took of the same thing — several
+    /// near-same shots (like three poses of the same cat) — by clustering the
+    /// whole library on visual similarity (looser than Look-alikes), then naming
+    /// each set from its Vision content tags (prettified by apfel if available).
+    /// No deletion — this is for browsing/curation.
     func scanSimilarSets(_ t: L10n) async {
         guard !isScanning else { return }
         isScanning = true
@@ -285,20 +287,36 @@ final class LibraryModel: ObservableObject {
         }
         let enr = enrichment ?? [:]
 
-        var buckets: [String: [Photo]] = [:]
-        var done = 0
-        for asset in assets {
-            if let label = await CategoryScanner.category(for: asset, manager: imageManager) {
-                buckets[label, default: []].append(makePhoto(from: asset, enr: enr))
-            }
-            done += 1
-            if done % 200 == 0 { progress = t.progClassifying(done, assets.count) }
+        // Cluster the library at the "same scene, different moment" band — looser
+        // than Look-alikes (which is now ≈identical only), so pose/angle changes
+        // still group (cats ≈0.3 feature distance land here, not in Look-alikes).
+        let idGroups = await LookAlikeScanner.scan(
+            assets: assets, manager: imageManager, t: t,
+            dHashDistance: 14, featureDistance: 0.45
+        ) { [weak self] msg in Task { @MainActor in self?.progress = msg } }
+
+        var albums: [CategoryBucket] = []
+        var i = 0
+        for ids in idGroups {
+            i += 1
+            if i % 10 == 0 { progress = t.progNaming(i, idGroups.count) }
+            let photos = ids.compactMap { map[$0] }.map { makePhoto(from: $0, enr: enr) }
+                .sorted { $0.takenAt < $1.takenAt }
+            guard photos.count >= 2 else { continue }
+            let name = await albumName(for: photos)
+            albums.append(CategoryBucket(label: name, photos: photos))
         }
+        categories = albums.sorted { $0.count > $1.count }
+    }
 
-        categories = buckets
-            .map { CategoryBucket(label: $0.key, photos: $0.value) }
-            .filter { $0.count >= 2 }
-            .sorted { $0.count > $1.count }
+    /// Name a set from the Vision tags of its representative frame, prettified by
+    /// apfel when available; otherwise the top tag (or a generic fallback).
+    private func albumName(for photos: [Photo]) async -> String {
+        guard let rep = photos.first, let asset = assetsByID[rep.uuid] else { return "Set" }
+        let tags = await CategoryScanner.labels(for: asset, manager: imageManager)
+        guard let top = tags.first else { return "Set" }
+        if let pretty = await Apfel.albumName(tags: tags) { return pretty }
+        return CategoryScanner.displayName(top)
     }
 
     /// Promote a frame to keeper (favorites stay protected either way).

app/Sources/SnapsiftApp/LookAlikeScanner.swift

@@ -20,7 +20,9 @@ enum LookAlikeScanner {
                      manager: PHCachingImageManager,
                      t: L10n,
                      dHashDistance: Int = 8,
-                     featureDistance: Float = 0.7,
+                     featureDistance: Float = 0.15,   // ≈0.0 for a true re-saved
+                                                      // copy; 0.15 excludes merely
+                                                      // similar shots (cats ≈0.3)
                      progress: @escaping (String) -> Void) async -> [[String]] {
 
         // Stage 1 — dHash all thumbnails (tiny 9×8 requests, fast).