togatoga
diff --git a/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion b/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎karukan-engine/src/learning.rs‎
Lines changed: 186 additions & 20 deletions b/‎karukan-engine/src/learning.rs‎
Lines changed: 186 additions & 20 deletions
diff --git a/‎karukan-engine/src/lib.rs‎
Lines changed: 1 addition & 1 deletion b/‎karukan-engine/src/lib.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎karukan-im/README.md‎
Lines changed: 4 additions & 1 deletion b/‎karukan-im/README.md‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎karukan-im/config/default.toml‎
Lines changed: 2 additions & 0 deletions b/‎karukan-im/config/default.toml‎
Lines changed: 2 additions & 0 deletions
@@ -188,7 +188,7 @@ The engine-internal `InputMode::Alphabet` (entered via Shift+letter on Linux/fci
 - Models use jinen format with special Unicode tokens (U+EE00–U+EE02) from the Private Use Area; model input is katakana (hiragana is converted to katakana before inference)
 - Model registry defined in `karukan-engine/models.toml`; default models use Q5_K_M quantization
 - Live conversion (auto-suggest) splits the composing buffer into internal chunks of at most `composing_chunk_len` reading chars (default 40, configurable) so each model call stays bounded for long input. Chunking (`group_chunks`) starts a new chunk whenever the current one is full OR the character group changes between Japanese and non-Japanese (`is_japanese`: hiragana, katakana incl. `ー`, and kanji are Japanese; ASCII/full-width digits, letters, symbols, and all punctuation are non-Japanese). A non-Japanese run (digits/symbols/alphabet) is passed through to the preedit verbatim and never sent to the neural converter (which otherwise tends to drop digits mid-run, e.g. `123456`); a Japanese run is converted by the model. Because punctuation is non-Japanese, it forms its own chunk and naturally separates clauses (`今日は。明日` → `今日は`/`。`/`明日`), so there is no separate punctuation rule. A katakana word like `スーパーマーケット` is entirely Japanese, so it stays one chunk. `chunked_auto_suggest` re-chunks incrementally: it diffs the new buffer against the previous chunking by common character prefix/suffix and reconverts only the changed span (`ChunkPlan` decides which leading/trailing chunks to reuse). Each chunk's left context (lctx) is the editor surrounding text plus the converted text of the preceding chunks, truncated to `max_context_length`. Chunks are internal — the user sees one continuous preedit, and the aux text shows the current chunk's lctx as its single `lctx:`
-- Learning cache records user-selected conversions and boosts them on subsequent conversions; candidate priority: Learning → User Dictionary → Model → System Dictionary → Fallback → Rewriter
+- Learning cache records user-selected conversions and boosts them on subsequent conversions; candidate priority: Learning → User Dictionary → Model → System Dictionary → Fallback → Rewriter. Surfaces longer than `max_surface_chars` (default 50, `[learning]` in config.toml; both learning limits travel as `LearningConfig`) are not recorded. During conversion, Ctrl+Backspace or Ctrl+Delete (the Mac "delete" key is Backspace) removes the selected learning candidate from the history, mozc-style (`DeleteSelectedCandidate`): the removal clears the entry's whole prefix fan-out (`LearningCache::remove_suggestion`) so deduped twins under longer readings can't resurface, and the conversion is then rebuilt in place (mozc's cancel-and-reconvert, minus the window blink) so a surface that the model/dictionary/fallback also produce survives as an ordinary candidate. With a non-learning candidate selected the chord is consumed but does nothing (mozc's `DoNothing`); cancelling stays on plain Backspace/Escape; the chord exists only in the Conversion state (Composing keeps plain char editing). Deletability is derived from `Candidate::source` (`CandidateSource::is_deletable`, mozc's `USER_HISTORY_PREDICTION` analogue), and while a learning candidate is selected the aux text shows the mozc-style footer hint 「Ctrl+Backspaceで履歴から削除」
 - Data files (system dictionary `dict.bin`, user dictionaries `user_dicts/`, learning cache `learning.tsv`) live in the data directory: `~/.local/share/karukan-im/` on Linux, `~/Library/Application Support/com.karukan.karukan-im/` on macOS; a prebuilt `dict.tgz` is published on GitHub releases
 - Learning cache is persisted as TSV (`learning.tsv` in the data directory); saved on deactivate and engine free, not on every commit
 - Learning score uses recency-weighted formula (mozc-inspired): `recency * 10.0 + ln(1 + frequency)`; eviction removes lowest-score entries when over `max_entries` (default: 10,000)
 
@@ -20,6 +20,38 @@ pub struct LearningEntry {
     pub last_access: u64,
 }
 
+/// Size limits for a [`LearningCache`].
+///
+/// Passed whole at construction ([`LearningCache::new`] /
+/// [`LearningCache::load`]) so a caller can't apply one limit and forget the
+/// other — there is no post-construction setter to miss.
+#[derive(Debug, Clone, Copy)]
+pub struct LearningConfig {
+    /// Maximum number of total entries across all readings; lowest-score
+    /// entries are evicted on save when over this limit.
+    pub max_entries: usize,
+    /// Maximum surface length (Unicode chars) that [`LearningCache::record`]
+    /// accepts. Keeps whole-sentence live-conversion commits — one-off text
+    /// that never matches again — out of the cache.
+    pub max_surface_chars: usize,
+}
+
+impl LearningConfig {
+    /// Default for [`max_entries`](Self::max_entries).
+    pub const DEFAULT_MAX_ENTRIES: usize = 10_000;
+    /// Default for [`max_surface_chars`](Self::max_surface_chars).
+    pub const DEFAULT_MAX_SURFACE_CHARS: usize = 50;
+}
+
+impl Default for LearningConfig {
+    fn default() -> Self {
+        Self {
+            max_entries: Self::DEFAULT_MAX_ENTRIES,
+            max_surface_chars: Self::DEFAULT_MAX_SURFACE_CHARS,
+        }
+    }
+}
+
 /// In-memory cache of user learning data.
 ///
 /// Keyed by reading (hiragana). Each reading maps to a list of surface
@@ -28,24 +60,29 @@ pub struct LearningEntry {
 pub struct LearningCache {
     entries: HashMap<String, Vec<LearningEntry>>,
     max_entries: usize,
+    max_surface_chars: usize,
     dirty: bool,
 }
 
 impl LearningCache {
-    /// Default maximum number of total entries across all readings.
-    pub const DEFAULT_MAX_ENTRIES: usize = 10_000;
-
-    /// Create an empty cache with the given entry limit.
-    pub fn new(max_entries: usize) -> Self {
+    /// Create an empty cache with the given limits.
+    pub fn new(config: LearningConfig) -> Self {
         Self {
             entries: HashMap::new(),
-            max_entries,
+            max_entries: config.max_entries,
+            max_surface_chars: config.max_surface_chars,
             dirty: false,
         }
     }
 
     /// Record a user selection. Increments frequency and updates last_access.
+    ///
+    /// Surfaces longer than `max_surface_chars` are skipped; see
+    /// [`LearningConfig::max_surface_chars`] for why.
     pub fn record(&mut self, reading: &str, surface: &str) {
+        if surface.chars().count() > self.max_surface_chars {
+            return;
+        }
         let now = now_unix();
         let entries = self.entries.entry(reading.to_string()).or_default();
 
@@ -62,6 +99,29 @@ impl LearningCache {
         self.dirty = true;
     }
 
+    /// Remove every learned entry that would resurface `surface` for input
+    /// `reading`: the exact-reading entry plus every longer reading with
+    /// `reading` as a prefix (the [`prefix_lookup`](Self::prefix_lookup)
+    /// fan-out) — an exact-only delete would leave a twin that pops back on
+    /// the next conversion. Returns whether anything was removed; persisted
+    /// at the next `save`.
+    pub fn remove_suggestion(&mut self, reading: &str, surface: &str) -> bool {
+        let mut removed = false;
+        self.entries.retain(|r, entries| {
+            if !r.starts_with(reading) {
+                return true;
+            }
+            let before = entries.len();
+            entries.retain(|e| e.surface != surface);
+            removed |= entries.len() != before;
+            !entries.is_empty()
+        });
+        if removed {
+            self.dirty = true;
+        }
+        removed
+    }
+
     /// Exact-match lookup: returns `(surface, score)` pairs sorted by score descending.
     pub fn lookup(&self, reading: &str) -> Vec<(String, f64)> {
         let now = now_unix();
@@ -96,10 +156,10 @@ impl LearningCache {
     ///
     /// Format: `reading\tsurface\tfrequency\tlast_access`
     /// Lines starting with `#` are comments.
-    pub fn load(path: &Path, max_entries: usize) -> anyhow::Result<Self> {
+    pub fn load(path: &Path, config: LearningConfig) -> anyhow::Result<Self> {
         let file = std::fs::File::open(path)?;
         let reader = std::io::BufReader::new(file);
-        let mut cache = Self::new(max_entries);
+        let mut cache = Self::new(config);
 
         for line in reader.lines() {
             let line = line?;
@@ -250,11 +310,23 @@ fn now_unix() -> u64 {
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    /// Config/cache with a custom entry limit and the default surface cap.
+    fn config_with(max_entries: usize) -> LearningConfig {
+        LearningConfig {
+            max_entries,
+            ..LearningConfig::default()
+        }
+    }
+
+    fn cache_with(max_entries: usize) -> LearningCache {
+        LearningCache::new(config_with(max_entries))
+    }
     use tempfile::NamedTempFile;
 
     #[test]
     fn test_record_and_lookup() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
 
         cache.record("きょう", "今日");
         cache.record("きょう", "京");
@@ -269,14 +341,14 @@ mod tests {
 
     #[test]
     fn test_lookup_empty() {
-        let cache = LearningCache::new(100);
+        let cache = cache_with(100);
         let results = cache.lookup("きょう");
         assert!(results.is_empty());
     }
 
     #[test]
     fn test_prefix_lookup() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
         cache.record("きょう", "今日");
         cache.record("きょうと", "京都");
         cache.record("あした", "明日");
@@ -291,15 +363,15 @@ mod tests {
 
     #[test]
     fn test_prefix_lookup_no_match() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
         cache.record("きょう", "今日");
         let results = cache.prefix_lookup("あ");
         assert!(results.is_empty());
     }
 
     #[test]
     fn test_save_and_load() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
         cache.record("きょう", "今日");
         cache.record("きょう", "今日");
         cache.record("きょう", "京");
@@ -311,7 +383,7 @@ mod tests {
         cache.save(&path).unwrap();
         assert!(!cache.is_dirty());
 
-        let loaded = LearningCache::load(&path, 100).unwrap();
+        let loaded = LearningCache::load(&path, config_with(100)).unwrap();
         assert!(!loaded.is_dirty());
         assert_eq!(loaded.entry_count(), 3);
 
@@ -322,7 +394,7 @@ mod tests {
 
     #[test]
     fn test_dirty_flag() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
         assert!(!cache.is_dirty());
 
         cache.record("きょう", "今日");
@@ -335,7 +407,7 @@ mod tests {
 
     #[test]
     fn test_eviction() {
-        let mut cache = LearningCache::new(3);
+        let mut cache = cache_with(3);
 
         // Add 5 entries
         cache.record("a", "A");
@@ -390,13 +462,13 @@ mod tests {
 
     #[test]
     fn test_load_nonexistent_file() {
-        let result = LearningCache::load(Path::new("/nonexistent/path"), 100);
+        let result = LearningCache::load(Path::new("/nonexistent/path"), config_with(100));
         assert!(result.is_err());
     }
 
     #[test]
     fn test_tsv_format() {
-        let mut cache = LearningCache::new(100);
+        let mut cache = cache_with(100);
         cache.record("きょう", "今日");
 
         let file = NamedTempFile::new().unwrap();
@@ -416,13 +488,107 @@ mod tests {
         )
         .unwrap();
 
-        let cache = LearningCache::load(file.path(), 100).unwrap();
+        let cache = LearningCache::load(file.path(), config_with(100)).unwrap();
         assert_eq!(cache.entry_count(), 1);
         let results = cache.lookup("きょう");
         assert_eq!(results.len(), 1);
         assert_eq!(results[0].0, "今日");
     }
 
+    #[test]
+    fn test_remove_suggestion_last_surface_drops_reading() {
+        let mut cache = cache_with(100);
+        cache.record("きょう", "今日");
+
+        assert!(cache.remove_suggestion("きょう", "今日"));
+        assert_eq!(cache.entry_count(), 0);
+        assert!(cache.lookup("きょう").is_empty());
+        assert!(cache.prefix_lookup("き").is_empty());
+    }
+
+    #[test]
+    fn test_remove_suggestion_clears_exact_and_prefix_twins() {
+        let mut cache = cache_with(100);
+        cache.record("あい", "藍");
+        cache.record("あいさ", "藍"); // same surface, longer reading (a twin)
+        cache.record("あい", "愛"); // different surface under the same reading
+        cache.record("うみ", "藍"); // same surface, unrelated reading
+
+        let file = NamedTempFile::new().unwrap();
+        cache.save(file.path()).unwrap();
+        assert!(!cache.is_dirty());
+
+        assert!(cache.remove_suggestion("あい", "藍"));
+        assert!(cache.is_dirty(), "removal must mark the cache dirty");
+
+        // Both the exact entry and the prefix twin are gone...
+        assert!(cache.lookup("あい").iter().all(|(s, _)| s != "藍"));
+        assert!(cache.lookup("あいさ").is_empty());
+        // ...but a different surface under the same reading survives...
+        assert!(cache.lookup("あい").iter().any(|(s, _)| s == "愛"));
+        // ...and the same surface under an unrelated reading is untouched.
+        assert!(cache.lookup("うみ").iter().any(|(s, _)| s == "藍"));
+    }
+
+    #[test]
+    fn test_remove_suggestion_nonexistent_is_noop() {
+        let mut cache = cache_with(100);
+        cache.record("あい", "藍");
+
+        let file = NamedTempFile::new().unwrap();
+        cache.save(file.path()).unwrap();
+
+        assert!(!cache.remove_suggestion("あい", "愛"));
+        assert!(!cache.remove_suggestion("かき", "柿"));
+        assert!(!cache.is_dirty(), "no-op removal must not mark dirty");
+    }
+
+    #[test]
+    fn test_record_skips_long_surface() {
+        let mut cache = LearningCache::new(LearningConfig {
+            max_entries: 100,
+            max_surface_chars: 5,
+        });
+
+        cache.record("あ", &"漢".repeat(6));
+        assert_eq!(cache.entry_count(), 0);
+        assert!(!cache.is_dirty());
+
+        // Boundary: exactly max_surface_chars is accepted.
+        cache.record("あ", &"漢".repeat(5));
+        assert_eq!(cache.entry_count(), 1);
+    }
+
+    #[test]
+    fn test_record_ignores_reading_length() {
+        let mut cache = LearningCache::new(LearningConfig {
+            max_entries: 100,
+            max_surface_chars: 5,
+        });
+
+        // Only the surface is capped; a long reading with a short surface
+        // is fine (e.g. a long kana reading converting to a short word).
+        cache.record(&"あ".repeat(30), "短い");
+        assert_eq!(cache.entry_count(), 1);
+    }
+
+    #[test]
+    fn test_default_max_surface_chars() {
+        let mut cache = cache_with(100);
+
+        cache.record(
+            "よみ",
+            &"あ".repeat(LearningConfig::DEFAULT_MAX_SURFACE_CHARS + 1),
+        );
+        assert_eq!(cache.entry_count(), 0);
+
+        cache.record(
+            "よみ",
+            &"あ".repeat(LearningConfig::DEFAULT_MAX_SURFACE_CHARS),
+        );
+        assert_eq!(cache.entry_count(), 1);
+    }
+
     #[test]
     fn test_tsv_malformed_lines_skipped() {
         let file = NamedTempFile::new().unwrap();
@@ -432,7 +598,7 @@ mod tests {
         )
         .unwrap();
 
-        let cache = LearningCache::load(file.path(), 100).unwrap();
+        let cache = LearningCache::load(file.path(), config_with(100)).unwrap();
         // Only the first valid line should be loaded
         assert_eq!(cache.entry_count(), 1);
     }
 
@@ -11,7 +11,7 @@ pub use kana::{
     katakana_to_hiragana, normalize_nfkc,
 };
 pub use kanji::{Backend, KanaKanjiConverter};
-pub use learning::LearningCache;
+pub use learning::{LearningCache, LearningConfig};
 pub use rewriter::{
     AlphabetRewriter, EmojiRewriter, HalfWidthKatakanaRewriter, RewriteOutput, Rewriter,
     RewriterChain, SymbolRewriter, description as symbol_description,
 
@@ -83,6 +83,7 @@ dict_path = "/path/to/dict.bin" # システム辞書パス（省略時はデー
 [learning]
 enabled = true                 # 変換学習の有効/無効
 max_entries = 10000            # 学習エントリの最大数
+max_surface_chars = 50         # 学習する変換結果の最大文字数
 ```
 
 > [!NOTE]
@@ -171,6 +172,8 @@ cp dict.bin ~/Library/"Application Support"/com.karukan.karukan-im/
   - 例: 「早稲田大学」を一度変換すると、次回「わせだ」と入力した時点で候補に表示
 - 学習候補は変換時・入力中（auto-suggest）の両方で最大3件表示
 - スコアはrecency（最終使用日時）重視 + 頻度補正
+- 50文字（`max_surface_chars`）を超える変換結果は学習しない
+- 変換中に学習候補（📝）を選択して `Ctrl+Backspace`（macOSでは Ctrl+delete。`Ctrl+Delete` でも可）を押すと、そのエントリを学習履歴から削除できる。学習候補の選択中はフッターに「Ctrl+Backspaceで履歴から削除」と表示される
 - IME切り替え・ウィンドウ切り替え時に自動保存（commit のたびには保存しない）
 - `[learning] enabled = false` で無効化可能
-- 学習履歴を削除するには: `rm ~/.local/share/karukan-im/learning.tsv`
+- 学習履歴をすべて削除するには: `rm ~/.local/share/karukan-im/learning.tsv`
@@ -36,3 +36,5 @@ live_conversion = true
 enabled = true
 # 学習エントリの最大数
 max_entries = 10000
+# 学習する変換結果の最大文字数
+max_surface_chars = 50