@bojackduy/opencode-learn 1.1.0 → 1.1.2

package/agents/classify.md

@@ -12,6 +12,7 @@ You map a learner's free-text note to quiz options. You are lenient for learner-
 Rules:
 
 - Only pick from given Options 1..N, no new options. Return inferred as indices that note best matches. Consider Vietnamese translations, synonyms, and "not fully" hedges.
+- Respect question type from prompt: if SINGLE-SELECT (default) you MUST return at most ONE inferred index ( [] or [k] ), never multiple — if note mentions several options, pick the single best. If MULTI-SELECT you may return 0..N. The prompt will state which mode.
 - Also judge semanticCorrect: true if note demonstrates valid understanding or deeper nuance, even when inferred != correct key. For standard facts (e.g., binary search requires sorted for vanilla), a note about rotate/mountain variant is valid nuance but the standard True still stands — in that case inferred is [2] but semanticCorrect may be true if note shows insight; the popup will show both.
 - Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"short reason in English"} — no extra text, no markdown.
 - If note is vague, empty, or "I don't know", inferred=[], semanticCorrect=false.

package/dist/server.js

@@ -525,27 +525,38 @@ var server = async ({ client, directory }) => {
   const loggedTextPartIds = new Set;
   const loggedToolCallIds = new Set;
   const messageIdToRole = new Map;
-  function heuristicClassify(note, options) {
+  function heuristicClassify(note, options, multiSelect) {
     const n = note.toLowerCase();
-    const out = [];
+    const scored = [];
     for (let i = 0;i < options.length; i++) {
       const o = options[i];
       const label = (o.label || "").toLowerCase();
       const value = (o.value || "").toLowerCase();
+      let score = 0;
       if (label && n.includes(label))
-        out.push(i + 1);
+        score = 3;
       else if (value && n.includes(value))
-        out.push(i + 1);
+        score = 2;
       else {
         const tokens = label.split(/[^a-z0-9]+/).filter((t) => t.length >= 3);
         if (tokens.some((t) => n.includes(t)))
-          out.push(i + 1);
+          score = 1;
       }
+      if (score)
+        scored.push({ idx: i + 1, score, len: label.length });
     }
-    return [...new Set(out)];
+    scored.sort((a, b) => b.score - a.score || b.len - a.len);
+    const out = scored.map((s) => s.idx);
+    const uniq = [...new Set(out)];
+    if (!multiSelect && uniq.length > 1) {
+      slog("heuristicClassify single-select trimmed", uniq.join(","), "->", uniq[0]);
+      return [uniq[0]];
+    }
+    return uniq;
   }
-  async function llmClassify(client2, directory2, note, options, question, parentSessionID) {
-    const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options.
+  async function llmClassify(client2, directory2, note, options, question, parentSessionID, multiSelect) {
+    const modeHint = multiSelect ? "This is a MULTI-SELECT question (0..N options may be correct). You may return 0..N inferred indices." : "This is a SINGLE-SELECT question (exactly 0 or 1 inferred). You MUST return at most ONE inferred index. Never return multiple. If note is ambiguous or mentions several options, pick the SINGLE best match. Return [] if vague.";
+    const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options. ${modeHint}
 
 ${question ? `Question: ${question}
 ` : ""}Options:
@@ -554,7 +565,7 @@ ${options.map((o, i) => `${i + 1}. ${o.label} (value: ${o.value || o.label})`).j
 
 Learner note: "${note}"
 
-Task: 1) inferred: which option(s) note best matches (Vietnamese translations/synonyms allowed). 2) semanticCorrect: true if note shows valid understanding or deeper nuance even when inferred != correct key (e.g., note about rotate array variant vs standard sorted is valid nuance). 3) reason: short English reason.
+Task: 1) inferred: which option(s) note best matches (Vietnamese translations/synonyms allowed) \u2014 respect single/multi mode above. 2) semanticCorrect: true if note shows valid understanding or deeper nuance even when inferred != correct key (e.g., note about rotate array variant vs standard sorted is valid nuance). 3) reason: short English reason.
 
 Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If vague/"I don't know", inferred:[], semanticCorrect:false. No markdown, just JSON.`;
     try {
@@ -582,14 +593,23 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
             const entry = arr[j];
             if (entry?.info?.role === "assistant") {
               const text = (entry.parts || []).filter((p) => p.type === "text").map((p) => p.text).join(" ") || "";
+              const enforceSingle = (arr2) => {
+                if (!multiSelect && arr2.length > 1) {
+                  const trimmed = [arr2[0]];
+                  slog("llmClassify enforce single", arr2.join(","), "->", trimmed.join(","), multiSelect ? "multi" : "single");
+                  return trimmed;
+                }
+                return arr2;
+              };
               const objMatch = text.match(/\{[^}]*"inferred"[^}]*\}/);
               if (objMatch) {
                 try {
                   const parsed = JSON.parse(objMatch[0]);
                   if (parsed && Array.isArray(parsed.inferred)) {
                     const nums = parsed.inferred.filter((n) => typeof n === "number" && n >= 1 && n <= options.length);
-                    slog("llmClassify success object", note.slice(0, 40), nums.join(","), `semantic:${parsed.semanticCorrect} reason:${parsed.reason || ""} sid:${sid}`);
-                    return { inferred: nums, semanticCorrect: !!parsed.semanticCorrect, reason: parsed.reason, sessionID: sid };
+                    const fnums = enforceSingle(nums);
+                    slog("llmClassify success object", note.slice(0, 40), nums.join(","), `->${fnums.join(",")}`, `semantic:${parsed.semanticCorrect} reason:${parsed.reason || ""} sid:${sid}`);
+                    return { inferred: fnums, semanticCorrect: !!parsed.semanticCorrect, reason: parsed.reason, sessionID: sid };
                   }
                 } catch {}
               }
@@ -600,16 +620,20 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
                   if (Array.isArray(parsed)) {
                     const nums = parsed.filter((n) => typeof n === "number" && n >= 1 && n <= options.length);
                     if (nums.length) {
-                      slog("llmClassify success array", note.slice(0, 40), nums.join(","));
-                      return { inferred: nums, sessionID: sid };
+                      const fnums = enforceSingle(nums);
+                      slog("llmClassify success array", note.slice(0, 40), nums.join(","), `->${fnums.join(",")}`);
+                      return { inferred: fnums, sessionID: sid };
                     }
                   }
                 } catch {}
               }
               if (text.includes("1") || text.includes("2")) {
                 const nums = [...text.matchAll(/\b([1-9])\b/g)].map((x) => parseInt(x[1])).filter((n) => n <= options.length);
-                if (nums.length)
-                  return { inferred: [...new Set(nums)], sessionID: sid };
+                if (nums.length) {
+                  const uniq = [...new Set(nums)];
+                  const fnums = enforceSingle(uniq);
+                  return { inferred: fnums, sessionID: sid };
+                }
               }
             }
           }
@@ -649,35 +673,53 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
       let inferred = [];
       let semanticCorrect;
       let reason;
-      const llmRes = await llmClassify(client2, directory2, data.note, data.options, data.question, data.sessionID);
+      const multi = !!data.multiSelect;
+      const llmRes = await llmClassify(client2, directory2, data.note, data.options, data.question, data.sessionID, multi);
       if (llmRes.inferred.length) {
         inferred = llmRes.inferred;
         semanticCorrect = llmRes.semanticCorrect;
         reason = llmRes.reason;
-        slog("classify llm hit", data.id, llmRes.inferred.join(","), `semantic:${semanticCorrect} sid:${llmRes.sessionID || ""}`);
+        slog("classify llm hit", data.id, llmRes.inferred.join(","), `semantic:${semanticCorrect} multi:${multi} sid:${llmRes.sessionID || ""}`);
       } else {
-        inferred = heuristicClassify(data.note, data.options);
+        inferred = heuristicClassify(data.note, data.options, multi);
         if (inferred.length)
-          slog("classify heuristic hit", data.id, inferred.join(","));
+          slog("classify heuristic hit", data.id, inferred.join(","), `multi:${multi}`);
         else
           slog("classify no match", data.id, `"${data.note.slice(0, 40)}"`);
       }
+      if (!multi && inferred.length > 1) {
+        const before = inferred.join(",");
+        inferred = [inferred[0]];
+        slog("classify enforce single at watcher", data.id, `${before} -> ${inferred.join(",")}`);
+      }
       const elapsed = Date.now() - start;
       if (elapsed < 1200)
         await new Promise((r) => setTimeout(r, 1200 - elapsed));
-      const inferredValues = inferred.map((i) => data.options[i - 1]?.value).filter(Boolean);
       if (!inferred.length && data.note) {
         const n = data.note.toLowerCase();
         for (const o of data.options) {
           const v = o.value ? String(o.value).toLowerCase() : "";
           if (v && n.includes(v) && !inferred.includes(byVal.get(o.value))) {
             const idx = byVal.get(o.value);
-            if (idx)
+            if (idx) {
               inferred.push(idx);
+              if (!multi)
+                break;
+            }
           }
         }
+        if (!multi && inferred.length > 1) {
+          slog("classify fallback enforce single", data.id, inferred.join(","));
+          inferred = [inferred[0]];
+        }
       }
-      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} sid:${llmRes?.sessionID || ""} note:"${data.note.slice(0, 60)}"`);
+      if (!multi && inferred.length > 1) {
+        const before2 = inferred.join(",");
+        inferred = [inferred[0]];
+        slog("classify final enforce single", data.id, `${before2} -> ${inferred.join(",")}`);
+      }
+      const inferredValues = inferred.map((i) => data.options[i - 1]?.value).filter(Boolean);
+      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} multi:${multi} sid:${llmRes?.sessionID || ""} note:"${data.note.slice(0, 60)}"`);
       const out = { id: data.id, inferredIndices: inferred, inferredValues, semanticCorrect, reason, classifySessionID: llmRes?.sessionID, note: data.note, at: Date.now() };
       try {
         fs.writeFileSync(respPath, JSON.stringify(out), "utf8");

package/dist/tui.js

@@ -387,6 +387,7 @@ function QuizDialog(props) {
             value: o.value,
             index: i + 1
           })),
+          multiSelect: isMulti(),
           timestamp: Date.now(),
           sessionID: props.request.sessionID || routeSessionID
         };
@@ -424,9 +425,12 @@ function QuizDialog(props) {
                 return idxs.length === props.request.correctIndices.length && idxs.every((v) => correctSet.has(v)) && props.request.correctIndices.every((v) => idxs.includes(v));
               };
               if (inferred && inferred.length) {
+                const eff = !isMulti() && inferred.length > 1 ? [inferred[0]] : inferred;
+                if (eff.length !== inferred.length)
+                  tlog("QuizDialog classify enforce single", inferred.join(","), "->", eff.join(","));
                 const m = new Map;
-                for (let i = 0;i < inferred.length; i++) {
-                  const idx = inferred[i];
+                for (let i = 0;i < eff.length; i++) {
+                  const idx = eff[i];
                   const opt = options()[idx - 1];
                   if (opt)
                     m.set(`opt:${idx - 1}`, {
@@ -436,17 +440,22 @@ function QuizDialog(props) {
                     });
                 }
                 setSelected(m);
-                const correct2 = computeCorrect(inferred);
+                const correct2 = computeCorrect(eff);
                 setFeedback({
                   correct: correct2,
-                  selectedIndices: inferred
+                  selectedIndices: eff
                 });
                 if (reason)
                   setNote((prev) => prev ? `${prev} \u2014 ${reason}` : prev);
-                tlog("QuizDialog classify done", inferred.join(","), correct2, reason || "");
+                tlog("QuizDialog classify done", eff.join(","), correct2, reason || "");
               } else if (inferredValues && inferredValues.length) {
                 const byVal = new Map(options().map((o, i) => [o.value, i + 1]));
-                const idxs = inferredValues.map((v) => byVal.get(v)).filter(Boolean);
+                let idxs = inferredValues.map((v) => byVal.get(v)).filter(Boolean);
+                if (!isMulti() && idxs.length > 1) {
+                  const b = idxs.join(",");
+                  idxs = [idxs[0]];
+                  tlog("QuizDialog classifyValues enforce single", b, "->", idxs.join(","));
+                }
                 const m = new Map;
                 for (const idx of idxs) {
                   const opt = options()[idx - 1];
@@ -589,17 +598,17 @@ function QuizDialog(props) {
       return;
     }
     if (focused() === "note") {
-      if (key === "tab" || seq === "\t") {
+      if (lower === "tab" || seq === "\t") {
         prevent(evt);
         setFocused("options");
         return;
       }
-      if (key === "escape" || key === "esc") {
+      if (lower === "escape" || lower === "esc") {
         prevent(evt);
         setFocused("options");
         return;
       }
-      if (key === "enter" && (evt.ctrl || evt.meta)) {
+      if (lower === "enter" && (evt.ctrl || evt.meta)) {
         prevent(evt);
         setFocused("options");
         return;
@@ -647,27 +656,27 @@ function QuizDialog(props) {
         return dontKnowIdx() + 1;
       return dontKnowIdx();
     };
-    if (key === "up" || key === "k" || seq === "\x1B[A") {
+    if (lower === "up" || isPlainKey(evt, "k") || seq === "\x1B[A") {
       prevent(evt);
       setOptionIndex((i) => Math.max(0, i - 1));
       return;
     }
-    if (key === "down" || key === "j" || seq === "\x1B[B") {
+    if (lower === "down" || isPlainKey(evt, "j") || seq === "\x1B[B") {
       prevent(evt);
       setOptionIndex((i) => Math.min(maxIdx(), i + 1));
       return;
     }
-    if (key === "tab" || seq === "\t") {
+    if (lower === "tab" || seq === "\t") {
       prevent(evt);
       setFocused("note");
       return;
     }
-    if (key === "escape" || key === "esc") {
+    if (lower === "escape" || lower === "esc") {
       prevent(evt);
       props.onCancel();
       return;
     }
-    if (key === "space" || seq === " ") {
+    if (lower === "space" || seq === " ") {
       prevent(evt);
       const idx = optionIndex();
       if (idx === dontKnowIdx())
@@ -692,7 +701,7 @@ function QuizDialog(props) {
       }
       return;
     }
-    if (key === "enter" || seq === "\r") {
+    if (lower === "enter" || seq === "\r") {
       prevent(evt);
       const idx = optionIndex();
       if (idx === dontKnowIdx())
@@ -715,7 +724,7 @@ function QuizDialog(props) {
       }
       return;
     }
-    if (seq === "ctrl+j" || key === "enter" && evt.ctrl) {
+    if (seq === "ctrl+j" || lower === "enter" && evt.ctrl) {
       prevent(evt);
       submitSelect();
       return;
@@ -1525,6 +1534,7 @@ function QuizBatchDialog(props) {
               value: o.value,
               index: i + 1
             })),
+            multiSelect: isMulti(),
             timestamp: Date.now(),
             sessionID: props.request.sessionID || routeSessionID
           };
@@ -1683,12 +1693,12 @@ function QuizBatchDialog(props) {
         return;
       }
       if (focused() === "note") {
-        if (k === "tab" || seq === "\t") {
+        if (lower === "tab" || seq === "\t") {
           prevent(evt);
           setFocused("options");
           return;
         }
-        if (k === "escape") {
+        if (lower === "escape" || lower === "esc") {
           prevent(evt);
           setFocused("options");
           return;
@@ -1713,27 +1723,27 @@ function QuizBatchDialog(props) {
         } catch {}
         return;
       }
-      if (k === "up" || k === "k" || seq === "\x1B[A") {
+      if (lower === "up" || isPlainKeyBatch(evt, "k") || seq === "\x1B[A") {
         prevent(evt);
         setOptionIndex((i) => Math.max(0, i - 1));
         return;
       }
-      if (k === "down" || k === "j" || seq === "\x1B[B") {
+      if (lower === "down" || isPlainKeyBatch(evt, "j") || seq === "\x1B[B") {
         prevent(evt);
         setOptionIndex((i) => Math.min(isMulti() ? submitIdx() : dontKnowIdx(), i + 1));
         return;
       }
-      if (k === "tab" || seq === "\t") {
+      if (lower === "tab" || seq === "\t") {
         prevent(evt);
         setFocused("note");
         return;
       }
-      if (k === "escape" || k === "esc") {
+      if (lower === "escape" || lower === "esc") {
         prevent(evt);
         props.onCancel();
         return;
       }
-      if (k === "space" || seq === " ") {
+      if (lower === "space" || seq === " ") {
         prevent(evt);
         const i = optionIndex();
         if (i === dontKnowIdx()) {
@@ -1759,7 +1769,7 @@ function QuizBatchDialog(props) {
         }
         return;
       }
-      if (k === "enter" || seq === "\r") {
+      if (lower === "enter" || seq === "\r") {
         prevent(evt);
         const i = optionIndex();
         if (i === dontKnowIdx()) {
@@ -1783,7 +1793,7 @@ function QuizBatchDialog(props) {
         }
         return;
       }
-      if (seq === "ctrl+j" || k === "enter" && evt.ctrl) {
+      if (seq === "ctrl+j" || lower === "enter" && evt.ctrl) {
         prevent(evt);
         submitSelect();
         return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Pi learn system for OpenCode — Socratic teaching, graded quiz, Obsidian md_log, and visual makers. Port of amosblomqvist/learn (video: How I Use AI to Learn Things) to OpenCode.",
   "type": "module",
   "license": "MIT",

package/plugins/learn-tui.tsx

@@ -183,7 +183,7 @@ function QuizDialog(props: {
       try {
         const pDir = (globalThis as any).__learnPendingDir || ".opencode/learn-pending"
         const routeSessionID = (props.api.route as any)?.current?.params?.sessionID
-        const pendingClassify = { id: props.request.id, type: "classify" as const, note: note().trim(), question: props.request.question, options: options().map((o: any, i: number) => ({ label: o.label, value: o.value, index: i + 1 })), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
+        const pendingClassify = { id: props.request.id, type: "classify" as const, note: note().trim(), question: props.request.question, options: options().map((o: any, i: number) => ({ label: o.label, value: o.value, index: i + 1 })), multiSelect: isMulti(), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
         fs.writeFileSync(path.join(pDir, `classify-${props.request.id}.json`), JSON.stringify(pendingClassify), "utf8")
         tlog("QuizDialog classify request", props.request.id, note().trim().slice(0, 50))
         // Poll for classify-response
@@ -207,20 +207,23 @@ function QuizDialog(props: {
                 return idxs.length === props.request.correctIndices.length && idxs.every((v: number) => correctSet.has(v)) && props.request.correctIndices.every((v: number) => idxs.includes(v))
               }
               if (inferred && inferred.length) {
+                const eff = !isMulti() && inferred.length > 1 ? [inferred[0]!] : inferred
+                if (eff.length !== inferred.length) tlog("QuizDialog classify enforce single", inferred.join(","), "->", eff.join(","))
                 const m = new Map<string, { label: string; value: string; index: number }>()
-                for (let i = 0; i < inferred.length; i++) {
-                  const idx = inferred[i]
+                for (let i = 0; i < eff.length; i++) {
+                  const idx = eff[i]
                   const opt = options()[idx - 1]
                   if (opt) m.set(`opt:${idx - 1}`, { label: opt.label, value: opt.value, index: idx })
                 }
                 setSelected(m)
-                const correct = computeCorrect(inferred)
-                setFeedback({ correct, selectedIndices: inferred })
+                const correct = computeCorrect(eff)
+                setFeedback({ correct, selectedIndices: eff })
                 if (reason) setNote(prev => prev ? `${prev} — ${reason}` : prev)
-                tlog("QuizDialog classify done", inferred.join(","), correct, reason || "")
+                tlog("QuizDialog classify done", eff.join(","), correct, reason || "")
               } else if (inferredValues && inferredValues.length) {
                 const byVal = new Map(options().map((o, i) => [o.value, i + 1]))
-                const idxs = inferredValues.map(v => byVal.get(v)).filter(Boolean) as number[]
+                let idxs = inferredValues.map(v => byVal.get(v)).filter(Boolean) as number[]
+                if (!isMulti() && idxs.length > 1) { const b=idxs.join(","); idxs=[idxs[0]!]; tlog("QuizDialog classifyValues enforce single", b, "->", idxs.join(",")) }
                 const m = new Map<string, { label: string; value: string; index: number }>()
                 for (const idx of idxs) { const opt = options()[idx - 1]; if (opt) m.set(`opt:${idx - 1}`, { label: opt.label, value: opt.value, index: idx }) }
                 setSelected(m)
@@ -286,9 +289,9 @@ function QuizDialog(props: {
     }
     // Note focused: handle Tab/Esc/Enter to exit note, otherwise let input handle typing
     if (focused() === "note") {
-      if (key === "tab" || seq === "\t") { prevent(evt); setFocused("options"); return }
-      if (key === "escape" || key === "esc") { prevent(evt); setFocused("options"); return }
-      if (key === "enter" && (evt.ctrl || evt.meta)) { prevent(evt); setFocused("options"); return }
+      if (lower === "tab" || seq === "\t") { prevent(evt); setFocused("options"); return }
+      if (lower === "escape" || lower === "esc") { prevent(evt); setFocused("options"); return }
+      if (lower === "enter" && (evt.ctrl || evt.meta)) { prevent(evt); setFocused("options"); return }
       // Allow typing to go to input; don't prevent
       return
     }
@@ -303,11 +306,11 @@ function QuizDialog(props: {
       if (note().trim() && !selected().size && !dontKnow()) return dontKnowIdx() + 1
       return dontKnowIdx()
     }
-    if (key === "up" || key === "k" || seq === "\x1b[A") { prevent(evt); setOptionIndex(i => Math.max(0, i - 1)); return }
-    if (key === "down" || key === "j" || seq === "\x1b[B") { prevent(evt); setOptionIndex(i => Math.min(maxIdx(), i + 1)); return }
-    if (key === "tab" || seq === "\t") { prevent(evt); setFocused("note"); return }
-    if (key === "escape" || key === "esc") { prevent(evt); props.onCancel(); return }
-    if (key === "space" || seq === " ") {
+    if (lower === "up" || isPlainKey(evt,"k") || seq === "\x1b[A") { prevent(evt); setOptionIndex(i => Math.max(0, i - 1)); return }
+    if (lower === "down" || isPlainKey(evt,"j") || seq === "\x1b[B") { prevent(evt); setOptionIndex(i => Math.min(maxIdx(), i + 1)); return }
+    if (lower === "tab" || seq === "\t") { prevent(evt); setFocused("note"); return }
+    if (lower === "escape" || lower === "esc") { prevent(evt); props.onCancel(); return }
+    if (lower === "space" || seq === " ") {
       prevent(evt)
       const idx = optionIndex()
       if (idx === dontKnowIdx()) handleDontKnow()
@@ -321,7 +324,7 @@ function QuizDialog(props: {
       }
       return
     }
-    if (key === "enter" || seq === "\r") {
+    if (lower === "enter" || seq === "\r") {
       prevent(evt)
       const idx = optionIndex()
       if (idx === dontKnowIdx()) handleDontKnow()
@@ -333,7 +336,7 @@ function QuizDialog(props: {
         }
       return
     }
-    if (seq === "ctrl+j" || (key === "enter" && (evt as any).ctrl)) {
+    if (seq === "ctrl+j" || (lower === "enter" && (evt as any).ctrl)) {
       prevent(evt); submitSelect(); return
     }
   })
@@ -588,7 +591,7 @@ function QuizBatchDialog(props: {
           const pDir = (globalThis as any).__learnPendingDir || ".opencode/learn-pending"
           const cid = `${props.request.id}-${idx()}`
           const routeSessionID = (props.api.route as any)?.current?.params?.sessionID
-          const pendingClassify = { id: cid, type: "classify" as const, note: note().trim(), question: cur().question, options: cur().options.map((o: any, i: number) => ({ label: o.label, value: o.value, index: i + 1 })), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
+          const pendingClassify = { id: cid, type: "classify" as const, note: note().trim(), question: cur().question, options: cur().options.map((o: any, i: number) => ({ label: o.label, value: o.value, index: i + 1 })), multiSelect: isMulti(), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
           fs.writeFileSync(path.join(pDir, `classify-${cid}.json`), JSON.stringify(pendingClassify), "utf8")
           tlog("QuizBatchDialog classify request", cid, note().trim().slice(0, 50))
           const respPath = path.join(pDir, `classify-response-${cid}.json`)
@@ -654,16 +657,16 @@ function QuizBatchDialog(props: {
         if (lower==="pageup"||seq==="\x1b[5~"){ prevent(evt); try{scrollRefBatch?.scrollBy(-scrollAmountBatch()); setTimeout(updateScrollBatch,30)}catch{} return }
         if (lower==="pagedown"||seq==="\x1b[6~"){ prevent(evt); try{scrollRefBatch?.scrollBy(scrollAmountBatch()); setTimeout(updateScrollBatch,30)}catch{} return }
         if(lower==="enter"||seq==="\r"||lower==="escape"||lower==="esc"){ prevent(evt); goNext() } return }
-      if(focused()==="note"){ if(k==="tab"||seq==="\t"){prevent(evt); setFocused("options"); return} if(k==="escape"){prevent(evt); setFocused("options"); return} return }
+      if(focused()==="note"){ if(lower==="tab"||seq==="\t"){prevent(evt); setFocused("options"); return} if(lower==="escape"||lower==="esc"){prevent(evt); setFocused("options"); return} return }
       if(phase()==="select" && (isPlainKeyBatch(evt,"d")||seq==="\x04")){ prevent(evt); try{scrollRefBatch?.scrollBy(scrollAmountBatch()); setTimeout(updateScrollBatch,30); setTimeout(updateScrollBatch,120)}catch{} return }
       if(phase()==="select" && (isPlainKeyBatch(evt,"u")||seq==="\x15")){ prevent(evt); try{scrollRefBatch?.scrollBy(-scrollAmountBatch()); setTimeout(updateScrollBatch,30); setTimeout(updateScrollBatch,120)}catch{} return }
-      if(k==="up"||k==="k"||seq==="\x1b[A"){prevent(evt); setOptionIndex(i=>Math.max(0,i-1)); return}
-      if(k==="down"||k==="j"||seq==="\x1b[B"){prevent(evt); setOptionIndex(i=>Math.min(isMulti()?submitIdx():dontKnowIdx(),i+1)); return}
-      if(k==="tab"||seq==="\t"){prevent(evt); setFocused("note"); return}
-      if(k==="escape"||k==="esc"){prevent(evt); props.onCancel(); return}
-      if(k==="space"||seq===" "){prevent(evt); const i=optionIndex(); if(i===dontKnowIdx()){ const willBe=!dontKnow(); setDontKnow(willBe); if(willBe) setSelected(new Map()); } else if(isMulti() && i===submitIdx()) submitSelect(); else if(isMulti()) toggle(i); else { const o=cur().options[i]; if(o){setSelected(new Map([[`opt:${i}`,{label:o.label,value:o.value,index:i+1}]])); setDontKnow(false); submitSelect()} } return}
-      if(k==="enter"||seq==="\r"){prevent(evt); const i=optionIndex(); if(i===dontKnowIdx()){ const willBe=!dontKnow(); setDontKnow(willBe); if(willBe) setSelected(new Map()); } else if(isMulti()) submitSelect(); else { const o=cur().options[i]; if(o){setSelected(new Map([[`opt:${i}`,{label:o.label,value:o.value,index:i+1}]])); setDontKnow(false); submitSelect()} } return}
-      if(seq==="ctrl+j" || (k==="enter" && evt.ctrl)){prevent(evt); submitSelect(); return}
+      if(lower==="up"||isPlainKeyBatch(evt,"k")||seq==="\x1b[A"){prevent(evt); setOptionIndex(i=>Math.max(0,i-1)); return}
+      if(lower==="down"||isPlainKeyBatch(evt,"j")||seq==="\x1b[B"){prevent(evt); setOptionIndex(i=>Math.min(isMulti()?submitIdx():dontKnowIdx(),i+1)); return}
+      if(lower==="tab"||seq==="\t"){prevent(evt); setFocused("note"); return}
+      if(lower==="escape"||lower==="esc"){prevent(evt); props.onCancel(); return}
+      if(lower==="space"||seq===" "){prevent(evt); const i=optionIndex(); if(i===dontKnowIdx()){ const willBe=!dontKnow(); setDontKnow(willBe); if(willBe) setSelected(new Map()); } else if(isMulti() && i===submitIdx()) submitSelect(); else if(isMulti()) toggle(i); else { const o=cur().options[i]; if(o){setSelected(new Map([[`opt:${i}`,{label:o.label,value:o.value,index:i+1}]])); setDontKnow(false); submitSelect()} } return}
+      if(lower==="enter"||seq==="\r"){prevent(evt); const i=optionIndex(); if(i===dontKnowIdx()){ const willBe=!dontKnow(); setDontKnow(willBe); if(willBe) setSelected(new Map()); } else if(isMulti()) submitSelect(); else { const o=cur().options[i]; if(o){setSelected(new Map([[`opt:${i}`,{label:o.label,value:o.value,index:i+1}]])); setDontKnow(false); submitSelect()} } return}
+      if(seq==="ctrl+j" || (lower==="enter" && evt.ctrl)){prevent(evt); submitSelect(); return}
     } catch(e){ tlog("useKeyboard batch failed", String(e)) }
   })
   return (

package/plugins/learn.ts

@@ -464,31 +464,41 @@ const server: Plugin = async ({ client, directory }) => {
   const messageIdToRole = new Map<string, string>()
 
   // ── Classify watcher: note → inferred options (learner-easy) — LLM-backed, not heuristic-only
-  function heuristicClassify(note: string, options: Array<{ label: string; value?: string }>): number[] {
+  function heuristicClassify(note: string, options: Array<{ label: string; value?: string }>, multiSelect?: boolean): number[] {
     const n = note.toLowerCase()
-    const out: number[] = []
+    const scored: Array<{ idx:number, score:number, len:number }> = []
     for (let i = 0; i < options.length; i++) {
       const o = options[i]
       const label = (o.label || "").toLowerCase()
       const value = (o.value || "").toLowerCase()
-      if (label && n.includes(label)) out.push(i + 1)
-      else if (value && n.includes(value)) out.push(i + 1)
+      let score = 0
+      if (label && n.includes(label)) score = 3
+      else if (value && n.includes(value)) score = 2
       else {
         const tokens = label.split(/[^a-z0-9]+/).filter(t => t.length >= 3)
-        if (tokens.some(t => n.includes(t))) out.push(i + 1)
+        if (tokens.some(t => n.includes(t))) score = 1
       }
+      if (score) scored.push({ idx: i + 1, score, len: label.length })
     }
-    return [...new Set(out)]
+    scored.sort((a,b)=> b.score - a.score || b.len - a.len)
+    const out = scored.map(s=> s.idx)
+    const uniq = [...new Set(out)]
+    if (!multiSelect && uniq.length > 1) {
+      slog("heuristicClassify single-select trimmed", uniq.join(","), "->", uniq[0])
+      return [uniq[0]!]
+    }
+    return uniq
   }
-  async function llmClassify(client: any, directory: string, note: string, options: Array<{ label: string; value?: string }>, question?: string, parentSessionID?: string): Promise<{ inferred: number[]; semanticCorrect?: boolean; reason?: string; sessionID?: string }> {
-    const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options.
+  async function llmClassify(client: any, directory: string, note: string, options: Array<{ label: string; value?: string }>, question?: string, parentSessionID?: string, multiSelect?: boolean): Promise<{ inferred: number[]; semanticCorrect?: boolean; reason?: string; sessionID?: string }> {
+    const modeHint = multiSelect ? "This is a MULTI-SELECT question (0..N options may be correct). You may return 0..N inferred indices." : "This is a SINGLE-SELECT question (exactly 0 or 1 inferred). You MUST return at most ONE inferred index. Never return multiple. If note is ambiguous or mentions several options, pick the SINGLE best match. Return [] if vague."
+    const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options. ${modeHint}
 
 ${question ? `Question: ${question}\n` : ""}Options:
 ${options.map((o, i) => `${i + 1}. ${o.label} (value: ${o.value || o.label})`).join("\n")}
 
 Learner note: "${note}"
 
-Task: 1) inferred: which option(s) note best matches (Vietnamese translations/synonyms allowed). 2) semanticCorrect: true if note shows valid understanding or deeper nuance even when inferred != correct key (e.g., note about rotate array variant vs standard sorted is valid nuance). 3) reason: short English reason.
+Task: 1) inferred: which option(s) note best matches (Vietnamese translations/synonyms allowed) — respect single/multi mode above. 2) semanticCorrect: true if note shows valid understanding or deeper nuance even when inferred != correct key (e.g., note about rotate array variant vs standard sorted is valid nuance). 3) reason: short English reason.
 
 Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If vague/"I don't know", inferred:[], semanticCorrect:false. No markdown, just JSON.`
     try {
@@ -515,6 +525,14 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
             const entry = arr[j]
             if (entry?.info?.role === "assistant") {
               const text = (entry.parts || []).filter((p: any) => p.type === "text").map((p: any) => p.text).join(" ") || ""
+              const enforceSingle = (arr:number[]) => {
+                if (!multiSelect && arr.length > 1) {
+                  const trimmed = [arr[0]!]
+                  slog("llmClassify enforce single", arr.join(","), "->", trimmed.join(","), multiSelect ? "multi" : "single")
+                  return trimmed
+                }
+                return arr
+              }
               // Try object JSON {"inferred":[2],"semanticCorrect":false}
               const objMatch = text.match(/\{[^}]*"inferred"[^}]*\}/)
               if (objMatch) {
@@ -522,8 +540,9 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
                   const parsed = JSON.parse(objMatch[0])
                   if (parsed && Array.isArray(parsed.inferred)) {
                     const nums = parsed.inferred.filter((n: any) => typeof n === "number" && n >= 1 && n <= options.length)
-                    slog("llmClassify success object", note.slice(0, 40), nums.join(","), `semantic:${parsed.semanticCorrect} reason:${parsed.reason || ""} sid:${sid}`)
-                    return { inferred: nums, semanticCorrect: !!parsed.semanticCorrect, reason: parsed.reason, sessionID: sid }
+                    const fnums = enforceSingle(nums)
+                    slog("llmClassify success object", note.slice(0, 40), nums.join(","), `->${fnums.join(",")}`, `semantic:${parsed.semanticCorrect} reason:${parsed.reason || ""} sid:${sid}`)
+                    return { inferred: fnums, semanticCorrect: !!parsed.semanticCorrect, reason: parsed.reason, sessionID: sid }
                   }
                 } catch {}
               }
@@ -534,15 +553,20 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
                   if (Array.isArray(parsed)) {
                     const nums = parsed.filter((n: any) => typeof n === "number" && n >= 1 && n <= options.length)
                     if (nums.length) {
-                      slog("llmClassify success array", note.slice(0, 40), nums.join(","))
-                      return { inferred: nums, sessionID: sid }
+                      const fnums = enforceSingle(nums)
+                      slog("llmClassify success array", note.slice(0, 40), nums.join(","), `->${fnums.join(",")}`)
+                      return { inferred: fnums, sessionID: sid }
                     }
                   }
                 } catch {}
               }
               if (text.includes("1") || text.includes("2")) {
                 const nums = [...text.matchAll(/\b([1-9])\b/g)].map(x => parseInt(x[1])).filter(n => n <= options.length)
-                if (nums.length) return { inferred: [...new Set(nums)], sessionID: sid }
+                if (nums.length) {
+                  const uniq = [...new Set(nums)]
+                  const fnums = enforceSingle(uniq)
+                  return { inferred: fnums, sessionID: sid }
+                }
               }
             }
           }
@@ -572,33 +596,52 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If va
       let inferred: number[] = []
       let semanticCorrect: boolean | undefined
       let reason: string | undefined
-      const llmRes = await llmClassify(client, directory, data.note, data.options, data.question, data.sessionID)
+      const multi = !!data.multiSelect
+      const llmRes = await llmClassify(client, directory, data.note, data.options, data.question, data.sessionID, multi)
       if (llmRes.inferred.length) {
         inferred = llmRes.inferred
         semanticCorrect = llmRes.semanticCorrect
         reason = llmRes.reason
-        slog("classify llm hit", data.id, llmRes.inferred.join(","), `semantic:${semanticCorrect} sid:${llmRes.sessionID || ""}`)
+        slog("classify llm hit", data.id, llmRes.inferred.join(","), `semantic:${semanticCorrect} multi:${multi} sid:${llmRes.sessionID || ""}`)
       } else {
-        inferred = heuristicClassify(data.note, data.options)
-        if (inferred.length) slog("classify heuristic hit", data.id, inferred.join(","))
+        inferred = heuristicClassify(data.note, data.options, multi)
+        if (inferred.length) slog("classify heuristic hit", data.id, inferred.join(","), `multi:${multi}`)
         else slog("classify no match", data.id, `"${data.note.slice(0, 40)}"`)
       }
+      // Enforce single-select at the watcher level too (defense in depth — prompt + llmClassify + heuristic may still return multi)
+      if (!multi && inferred.length > 1) {
+        const before = inferred.join(",")
+        inferred = [inferred[0]!]
+        slog("classify enforce single at watcher", data.id, `${before} -> ${inferred.join(",")}`)
+      }
       // Ensure minimal classify time so UI doesn't feel instant-wrong (at least 1200ms)
       const elapsed = Date.now() - start
       if (elapsed < 1200) await new Promise(r => setTimeout(r, 1200 - elapsed))
-      const inferredValues = inferred.map((i: number) => data.options[i - 1]?.value).filter(Boolean) as string[]
-      // Final fallback if still empty
+      // Final fallback if still empty (respects single-select)
       if (!inferred.length && data.note) {
         const n = data.note.toLowerCase()
         for (const o of data.options) {
           const v = o.value ? String(o.value).toLowerCase() : ""
           if (v && n.includes(v) && !inferred.includes(byVal.get(o.value) as number)) {
             const idx = byVal.get(o.value) as number | undefined
-            if (idx) inferred.push(idx)
+            if (idx) {
+              inferred.push(idx)
+              if (!multi) break
+            }
           }
         }
+        if (!multi && inferred.length > 1) {
+          slog("classify fallback enforce single", data.id, inferred.join(","))
+          inferred = [inferred[0]!]
+        }
       }
-      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} sid:${(llmRes as any)?.sessionID || ""} note:"${data.note.slice(0, 60)}"`)
+      if (!multi && inferred.length > 1) {
+        const before2 = inferred.join(",")
+        inferred = [inferred[0]!]
+        slog("classify final enforce single", data.id, `${before2} -> ${inferred.join(",")}`)
+      }
+      const inferredValues = inferred.map((i: number) => data.options[i - 1]?.value).filter(Boolean) as string[]
+      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} multi:${multi} sid:${(llmRes as any)?.sessionID || ""} note:"${data.note.slice(0, 60)}"`)
       const out = { id: data.id, inferredIndices: inferred, inferredValues, semanticCorrect, reason, classifySessionID: (llmRes as any)?.sessionID, note: data.note, at: Date.now() }
       try { fs.writeFileSync(respPath, JSON.stringify(out), "utf8"); slog("classify response written", data.id, inferred.join(",")) } catch {}
     }