@bojackduy/opencode-learn 0.1.5 → 0.1.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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

@@ -22,6 +22,7 @@ type QuizPending = {
   correctIndices: number[]
   explanation: string
   multiSelect?: boolean
+  sessionID?: string
   timestamp: number
 }
 type QuizBatchPending = {
@@ -44,6 +45,7 @@ function QuizDialog(props: {
   const theme = () => props.api.theme.current
   const dims = useTerminalDimensions()
   const popupWidth = () => Math.max(68, Math.min(dims().width - 4, 92))
+  const popupHeight = () => Math.max(4, Math.min(24, dims().height - 2))
   const options = () => props.request.options
   const correctSet = new Set(props.request.correctIndices)
   const isMulti = () => !!props.request.multiSelect
@@ -52,7 +54,7 @@ function QuizDialog(props: {
 
   const [focused, setFocused] = createSignal<"options" | "note">("options")
   const [optionIndex, setOptionIndex] = createSignal(0)
-  const [phase, setPhase] = createSignal<"select" | "feedback">("select")
+  const [phase, setPhase] = createSignal<"select" | "feedback" | "classifying">("select")
   const [note, setNote] = createSignal("")
   const [dontKnow, setDontKnow] = createSignal(false)
   const [selected, setSelected] = createSignal<Map<string, { label: string; value: string; index: number }>>(new Map())
@@ -86,8 +88,71 @@ function QuizDialog(props: {
   }
   const submitSelect = () => {
     const selMap = selected()
-    if (!isMulti() && selMap.size === 0 && !dontKnow()) return
-    if (isMulti() && selMap.size === 0 && !dontKnow()) return
+    if (!isMulti() && selMap.size === 0 && !dontKnow() && !note().trim()) return
+    if (isMulti() && selMap.size === 0 && !dontKnow() && !note().trim()) return
+    // If 0 selected but note present, trigger AI classify (async popup) — keep popup, show classifying
+    if (selMap.size === 0 && !dontKnow() && note().trim()) {
+      setPhase("classifying" as any)
+      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 }
+        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
+        const respPath = path.join(pDir, `classify-response-${props.request.id}.json`)
+        let attempts = 0
+        const poll = setInterval(() => {
+          attempts++
+          if (attempts > 60) { clearInterval(poll); setPhase("feedback"); setFeedback({ correct: false, selectedIndices: [] }); return }
+          try {
+            if (fs.existsSync(respPath)) {
+              clearInterval(poll)
+              const raw = fs.readFileSync(respPath, "utf8")
+              const data: any = JSON.parse(raw)
+              try { fs.unlinkSync(respPath); fs.unlinkSync(path.join(pDir, `classify-${props.request.id}.json`)) } catch {}
+              const inferred = data?.inferredIndices as number[] | undefined
+              const inferredValues = data?.inferredValues as string[] | undefined
+              const semanticCorrect = data?.semanticCorrect as boolean | undefined
+              const reason = data?.reason as string | undefined
+              const computeCorrect = (idxs: number[]) => {
+                if (typeof semanticCorrect === "boolean") return semanticCorrect
+                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 m = new Map<string, { label: string; value: string; index: number }>()
+                for (let i = 0; i < inferred.length; i++) {
+                  const idx = inferred[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 })
+                if (reason) setNote(prev => prev ? `${prev} — ${reason}` : prev)
+                tlog("QuizDialog classify done", inferred.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[]
+                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)
+                const correct = computeCorrect(idxs)
+                setFeedback({ correct, selectedIndices: idxs })
+              } else {
+                const correct = typeof semanticCorrect === "boolean" ? semanticCorrect : false
+                setFeedback({ correct, selectedIndices: [] })
+                if (reason) setNote(prev => prev ? `${prev} — ${reason}` : reason)
+              }
+              setPhase("feedback")
+            }
+          } catch {}
+        }, 500)
+        // Cleanup on dispose
+        onCleanup(() => clearInterval(poll))
+      } catch (e) { tlog("classify request failed", String(e)); setPhase("feedback"); setFeedback({ correct: false, selectedIndices: [] }) }
+      return
+    }
     if (dontKnow()) {
       setFeedback({ correct: false, selectedIndices: [] })
       setPhase("feedback")
@@ -108,6 +173,7 @@ function QuizDialog(props: {
   useKeyboard((evt: any) => {
     const key = evt.name || evt.sequence || evt.raw || ""
     const seq = evt.sequence || ""
+    if ((phase() as any) === "classifying") { prevent(evt); return }
     // When in feedback, any Enter/Esc confirms
     if (phase() === "feedback") {
       if (key === "enter" || seq === "\r" || key === "escape" || key === "esc") {
@@ -124,15 +190,21 @@ function QuizDialog(props: {
       // Allow typing to go to input; don't prevent
       return
     }
-    // Options focused
+    // Options focused — extra Submit for single note-only at dontKnowIdx+1
+    const maxIdx = () => {
+      if (isMulti()) return submitIdx()
+      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(isMulti() ? submitIdx() : dontKnowIdx(), 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 === " ") {
       prevent(evt)
       const idx = optionIndex()
       if (idx === dontKnowIdx()) handleDontKnow()
+      else if (!isMulti() && idx === dontKnowIdx() + 1 && note().trim() && !selected().size && !dontKnow()) submitSelect()
       else {
         if (isMulti()) toggleOption(idx)
         else {
@@ -146,6 +218,7 @@ function QuizDialog(props: {
       prevent(evt)
       const idx = optionIndex()
       if (idx === dontKnowIdx()) handleDontKnow()
+      else if (!isMulti() && idx === dontKnowIdx() + 1 && note().trim() && !selected().size && !dontKnow()) submitSelect()
       else if (isMulti()) submitSelect()
       else {
           const opt = options()[idx]
@@ -159,13 +232,14 @@ function QuizDialog(props: {
   })
 
   return (
-    <box flexDirection="column" width={popupWidth()} border={true} borderColor={phase() === "feedback" ? (feedback()?.correct ? theme().success : theme().error) : theme().accent} backgroundColor={theme().backgroundPanel} padding={1} gap={1}>
+    <box flexDirection="column" width={popupWidth()} height={popupHeight()} border={true} borderColor={phase() === "feedback" ? (feedback()?.correct ? theme().success : theme().error) : theme().accent} backgroundColor={theme().backgroundPanel} padding={1} gap={1}>
         {/* Header */}
         <box flexDirection="row" justifyContent="space-between" alignItems="center" backgroundColor={phase() === "feedback" ? (feedback()?.correct ? theme().success : theme().error) : theme().accent} paddingLeft={1} paddingRight={1} height={1}>
           <text fg={theme().background} bold>{phase() === "feedback" ? (feedback()?.correct ? "✓  CORRECT" : dontKnow() ? "○  I DON'T KNOW" : "✗  INCORRECT") : isMulti() ? "☑  QUIZ · MULTI-SELECT" : "●  QUIZ · SINGLE" }</text>
           <text fg={theme().background} dim>learn</text>
         </box>
 
+        <scrollbox flexGrow={1}>
         {/* Question */}
         <box flexDirection="column" gap={1} paddingLeft={1} paddingRight={1} paddingTop={1}>
           <text fg={theme().text} bold wrapMode="wrap">{props.request.question}</text>
@@ -208,25 +282,44 @@ function QuizDialog(props: {
                     ref={(el: any) => noteInputEl = el}
                     value={note()}
                     onInput={(value: any) => setNote(typeof value === "string" ? value : value?.target?.value ?? value?.value ?? String(value ?? ""))}
-                    onSubmit={() => setFocused("options")}
-                    placeholder="what was on your mind?"
+                    onSubmit={() => {
+                      if (!selected().size && !dontKnow() && note().trim()) submitSelect()
+                      else setFocused("options")
+                    }}
+                    placeholder="what was on your mind? (Enter to submit note → classify)"
                   />
                 </Show>
               </box>
             </box>
 
             <box flexDirection="row" justifyContent="space-between" paddingTop={1}>
-              <text fg={theme().textMuted}>↑↓/j k  ·  Space toggle  ·  ↓ to Submit → Enter  ·  Tab note  ·  Esc cancel</text>
-              <Show when={isMulti()}><text fg={selected().size > 0 || dontKnow() ? theme().success : theme().warning}>{selected().size} selected {dontKnow() ? "· I don't know" : ""}</text></Show>
+              <text fg={theme().textMuted}>{focused() === "note" ? "Enter submit note → classify · Tab back · Esc back" : "↑↓/j k  ·  Space toggle  ·  ↓ to Submit → Enter  ·  Tab note  ·  Esc cancel"}</text>
+              <Show when={isMulti()}><text fg={selected().size > 0 || dontKnow() ? theme().success : note().trim() ? theme().warning : theme().warning}>{selected().size > 0 ? `${selected().size} selected` : note().trim() ? "note → classify" : "0 selected"} {dontKnow() ? "· I don't know" : ""}</text></Show>
+              <Show when={!isMulti() && note().trim() && !selected().size && !dontKnow()}><text fg={theme().warning}>note → classify on Enter</text></Show>
             </box>
             <Show when={isMulti()}>
               <box justifyContent="center" paddingTop={1}>
-                <box flexDirection="row" alignItems="center" gap={1} border={true} borderColor={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() ? theme().success : theme().borderSubtle)} backgroundColor={focused() === "options" && optionIndex() === submitIdx() ? theme().backgroundElement : (selected().size > 0 || dontKnow() ? theme().success : theme().background)} paddingLeft={2} paddingRight={2}>
-                  <text fg={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() ? theme().background : theme().textMuted)}>{focused() === "options" && optionIndex() === submitIdx() ? "▸" : " "}</text>
-                  <text fg={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() ? theme().background : theme().textMuted)} bold>↳  Submit</text>
+                <box flexDirection="row" alignItems="center" gap={1} border={true} borderColor={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() || note().trim() ? theme().success : theme().borderSubtle)} backgroundColor={focused() === "options" && optionIndex() === submitIdx() ? theme().backgroundElement : (selected().size > 0 || dontKnow() || note().trim() ? theme().success : theme().background)} paddingLeft={2} paddingRight={2}>
+                  <text fg={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() || note().trim() ? theme().background : theme().textMuted)}>{focused() === "options" && optionIndex() === submitIdx() ? "▸" : " "}</text>
+                  <text fg={focused() === "options" && optionIndex() === submitIdx() ? theme().accent : (selected().size > 0 || dontKnow() || note().trim() ? theme().background : theme().textMuted)} bold>↳  Submit{note().trim() && !selected().size && !dontKnow() ? " note" : ""}</text>
                 </box>
               </box>
             </Show>
+            <Show when={!isMulti() && note().trim() && !selected().size && !dontKnow()}>
+              <box justifyContent="center" paddingTop={1}>
+                <box flexDirection="row" alignItems="center" gap={1} border={true} borderColor={focused() === "options" && optionIndex() === dontKnowIdx() + 1 ? theme().accent : theme().success} backgroundColor={focused() === "options" && optionIndex() === dontKnowIdx() + 1 ? theme().backgroundElement : theme().success} paddingLeft={2} paddingRight={2}>
+                  <text fg={focused() === "options" && optionIndex() === dontKnowIdx() + 1 ? theme().accent : theme().background} bold>↳  Submit note → classify</text>
+                </box>
+              </box>
+            </Show>
+          </box>
+        </Show>
+
+        <Show when={(phase() as any) === "classifying"}>
+          <box flexDirection="column" gap={1} padding={1} border={true} borderColor={theme().accent} backgroundColor={theme().background} alignItems="center">
+            <text fg={theme().accent} bold>◐ Classifying your note...</text>
+            <text fg={theme().textMuted} wrapMode="wrap">"{note()}"</text>
+            <text fg={theme().textMuted}>Mapping to options — please wait</text>
           </box>
         </Show>
 
@@ -260,9 +353,14 @@ function QuizDialog(props: {
             <box border={true} borderColor={theme().borderSubtle} backgroundColor={theme().backgroundPanel} padding={1}>
               <text fg={theme().text} wrapMode="wrap">{props.request.explanation}</text>
             </box>
-            <box justifyContent="center" paddingTop={1}><text fg={theme().textMuted}>↵ Enter / Esc to continue  →  next probe</text></box>
           </box>
         </Show>
+        </scrollbox>
+        <box height={1} justifyContent="center">
+          <text fg={theme().textMuted}>
+            {phase() === "feedback" ? "↵ Enter / Esc to continue  →  next probe" : phase() === "classifying" ? "Classifying your note..." : "Navigate options · Tab note · Esc cancel"}
+          </text>
+        </box>
       </box>
   )
 }
@@ -277,6 +375,7 @@ function QuizBatchDialog(props: {
   const theme = () => props.api.theme.current
   const dims = useTerminalDimensions()
   const popupWidth = () => Math.max(68, Math.min(dims().width - 4, 96))
+  const popupHeight = () => Math.max(4, Math.min(24, dims().height - 2))
   const [idx, setIdx] = createSignal(0)
   // Guard: if no quizzes, cancel
   if (!props.request.quizzes || props.request.quizzes.length === 0) {
@@ -285,7 +384,7 @@ function QuizBatchDialog(props: {
     return null as any
   }
   const cur = () => props.request.quizzes[idx()] ?? props.request.quizzes[0]
-  const [phase, setPhase] = createSignal<"select" | "feedback">("select")
+  const [phase, setPhase] = createSignal<"select" | "feedback" | "classifying">("select")
   const [feedback, setFeedback] = createSignal<{ correct: boolean; selectedIndices: number[] } | null>(null)
   const [dontKnow, setDontKnow] = createSignal(false)
   const [selected, setSelected] = createSignal<Map<string, any>>(new Map())
@@ -329,8 +428,58 @@ function QuizBatchDialog(props: {
   const submitSelect = () => {
     try {
       const m = selected()
-      if (!isMulti() && m.size===0 && !dontKnow()) return
-      if (isMulti() && m.size===0 && !dontKnow()) return
+      if (!isMulti() && m.size===0 && !dontKnow() && !note().trim()) return
+      if (isMulti() && m.size===0 && !dontKnow() && !note().trim()) return
+      // 0 selected + note -> AI classify, keep popup
+      if (m.size===0 && !dontKnow() && note().trim()) {
+        setPhase("classifying" as any)
+        try {
+          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 }
+          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`)
+          let attempts = 0
+          const poll = setInterval(() => {
+            attempts++
+            if (attempts > 60) { clearInterval(poll); setFeedback({ correct: false, selectedIndices: [] }); setPhase("feedback"); return }
+            try {
+              if (fs.existsSync(respPath)) {
+                clearInterval(poll)
+                const raw = fs.readFileSync(respPath, "utf8")
+                const data: any = JSON.parse(raw)
+                try { fs.unlinkSync(respPath); fs.unlinkSync(path.join(pDir, `classify-${cid}.json`)) } catch {}
+                const inferred = data?.inferredIndices as number[] | undefined
+                const semanticCorrect = data?.semanticCorrect as boolean | undefined
+                const reason = data?.reason as string | undefined
+                const computeOk2 = (idxs: number[]) => {
+                  if (typeof semanticCorrect === "boolean") return semanticCorrect
+                  const correctSet2 = new Set(cur().correctIndices)
+                  return idxs.length === cur().correctIndices.length && idxs.every(v => correctSet2.has(v)) && cur().correctIndices.every(v => idxs.includes(v))
+                }
+                if (inferred && inferred.length) {
+                  const mm = new Map<string, any>()
+                  for (const idx of inferred) { const opt = cur().options[idx - 1]; if (opt) mm.set(`opt:${idx - 1}`, { label: opt.label, value: opt.value, index: idx }) }
+                  setSelected(mm)
+                  const ok2 = computeOk2(inferred)
+                  setFeedback({ correct: ok2, selectedIndices: inferred })
+                  if (reason) setNote(prev => prev ? `${prev} — ${reason}` : prev)
+                  tlog("QuizBatchDialog classify done", inferred.join(","), ok2, reason || "")
+                } else {
+                  const ok2 = typeof semanticCorrect === "boolean" ? semanticCorrect : false
+                  setFeedback({ correct: ok2, selectedIndices: [] })
+                  if (reason) setNote(prev => prev ? `${prev} — ${reason}` : reason)
+                }
+                setPhase("feedback")
+              }
+            } catch {}
+          }, 500)
+          onCleanup(() => clearInterval(poll))
+        } catch (e) { tlog("classify batch failed", String(e)); setFeedback({ correct: false, selectedIndices: [] }); setPhase("feedback") }
+        return
+      }
       const sel = Array.from(m.values())
       const dk = dontKnow()
       const correctSet = new Set(cur().correctIndices)
@@ -344,6 +493,7 @@ function QuizBatchDialog(props: {
   useKeyboard((evt:any)=>{
     try {
       const k=evt.name||evt.sequence||evt.raw||""; const seq=evt.sequence||""
+      if((phase() as any)==="classifying"){ prevent(evt); return }
       if(phase()==="feedback"){ if(k==="enter"||seq==="\r"||k==="escape"||k==="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(k==="up"||k==="k"||seq==="\x1b[A"){prevent(evt); setOptionIndex(i=>Math.max(0,i-1)); return}
@@ -356,11 +506,12 @@ function QuizBatchDialog(props: {
     } catch(e){ tlog("useKeyboard batch failed", String(e)) }
   })
   return (
-    <box flexDirection="column" width={popupWidth()} border={true} borderColor={phase()==="feedback"?(feedback()?.correct?theme().success:theme().error):theme().accent} backgroundColor={theme().backgroundPanel} padding={1} gap={1}>
+    <box flexDirection="column" width={popupWidth()} height={popupHeight()} border={true} borderColor={phase()==="feedback"?(feedback()?.correct?theme().success:theme().error):theme().accent} backgroundColor={theme().backgroundPanel} padding={1} gap={1}>
       <box flexDirection="row" justifyContent="space-between" backgroundColor={theme().accent} paddingLeft={1} paddingRight={1} height={1}>
         <text fg={theme().background} bold> decks.quiz batch  {idx()+1}/{props.request.quizzes.length} {phase()==="feedback"?(feedback()?.correct?"✓":"✗"):""}</text>
         <text fg={theme().background} dim>learn</text>
       </box>
+      <scrollbox flexGrow={1}>
       <text fg={theme().text} bold wrapMode="wrap">{cur().question}</text>
       <Show when={cur().details}><text fg={theme().textMuted} wrapMode="wrap">{cur().details}</text></Show>
       <Show when={phase()==="select"}>
@@ -368,20 +519,32 @@ function QuizBatchDialog(props: {
           <For each={cur().options}>{(opt:any,i:any)=>{const id=i(); const foc=()=>focused()==="options"&&optionIndex()===id; const sel=()=>selected().has(`opt:${id}`); return <box flexDirection="row" alignItems="flexStart" gap={1} paddingLeft={1} backgroundColor={foc()?theme().backgroundElement:undefined}><box width={2}><text fg={foc()?theme().accent:theme().textMuted}>{foc()?"▸":" "}</text></box><box width={2}><text fg={isMulti()?(sel()?theme().success:theme().textMuted):(sel()?theme().accent:theme().textMuted)}>{isMulti()?(sel()?"☑":"☐"):(sel()?"⬢":"○")}</text></box><box flexGrow={1}><text fg={sel()?theme().text:theme().textMuted} bold={foc()} wrapMode="wrap">{id+1}. {opt.label}</text></box></box>}}</For>
           <box height={1}><text fg={theme().borderSubtle}>{"─".repeat(Math.max(20,popupWidth()-8))}</text></box>
           <box flexDirection="row" gap={1} paddingLeft={1} backgroundColor={focused()==="options"&&optionIndex()===dontKnowIdx()?theme().backgroundElement:undefined}><box width={2}><text fg={focused()==="options"&&optionIndex()===dontKnowIdx()?theme().accent:theme().textMuted}>{focused()==="options"&&optionIndex()===dontKnowIdx()?"▸":" "}</text></box><box width={2}><text fg={dontKnow()?theme().warning:theme().textMuted}>{dontKnow()?"☑":"☐"}</text></box><box flexGrow={1}><text fg={dontKnow()?theme().warning:theme().textMuted} italic>I don't know</text></box></box>
-          <box flexDirection="column" paddingTop={1}><text fg={focused()==="note"?theme().accent:theme().textMuted}>✎ Note</text><box border={true} borderColor={focused()==="note"?theme().accent:theme().borderSubtle} backgroundColor={theme().backgroundElement} paddingLeft={1} paddingRight={1}><Show when={focused()==="note"} fallback={<text fg={theme().textMuted}>{note()||"Tab to edit"}</text>}><input ref={(el:any)=>noteEl=el} value={note()} onInput={(v:any)=>setNote(typeof v==="string"?v:v?.target?.value??"")} onSubmit={()=>setFocused("options")} placeholder="note" /></Show></box></box>
-          <box flexDirection="row" justifyContent="space-between" paddingTop={1}><text fg={theme().textMuted}>Space toggle · ↓ to Submit → Enter · Tab note · Ctrl+Enter submit</text><text fg={theme().textMuted}>{idx()+1}/{props.request.quizzes.length}</text></box>
+          <box flexDirection="column" paddingTop={1}><text fg={focused()==="note"?theme().accent:theme().textMuted}>✎ Note</text><box border={true} borderColor={focused()==="note"?theme().accent:theme().borderSubtle} backgroundColor={theme().backgroundElement} paddingLeft={1} paddingRight={1}><Show when={focused()==="note"} fallback={<text fg={theme().textMuted}>{note()||"Tab to edit · share what you were thinking"}</text>}><input ref={(el:any)=>noteEl=el} value={note()} onInput={(v:any)=>setNote(typeof v==="string"?v:v?.target?.value??"")} onSubmit={()=>{ if (!selected().size && !dontKnow() && note().trim()) submitSelect(); else setFocused("options") }} placeholder="note (Enter to submit note → classify)" /></Show></box></box>
+          <box flexDirection="row" justifyContent="space-between" paddingTop={1}><text fg={theme().textMuted}>{focused()==="note" ? "Enter submit note → classify · Tab back · Esc back" : "Space toggle · ↓ to Submit → Enter · Tab note · Ctrl+Enter submit"}</text><text fg={theme().textMuted}>{idx()+1}/{props.request.quizzes.length}</text></box>
           <Show when={isMulti()}><box justifyContent="center" paddingTop={1}><box flexDirection="row" gap={1} border={true} borderColor={focused()==="options"&&optionIndex()===submitIdx()?theme().accent:theme().borderSubtle} backgroundColor={focused()==="options"&&optionIndex()===submitIdx()?theme().backgroundElement:theme().background} paddingLeft={2} paddingRight={2}><text fg={focused()==="options"&&optionIndex()===submitIdx()?theme().accent:theme().textMuted}>{focused()==="options"&&optionIndex()===submitIdx()?"▸":" "}</text><text bold>↳ Submit</text></box></box></Show>
         </box>
       </Show>
+      <Show when={(phase() as any)==="classifying"}>
+        <box flexDirection="column" gap={1} padding={1} border={true} borderColor={theme().accent} backgroundColor={theme().background} alignItems="center">
+          <text fg={theme().accent} bold>◐ Classifying your note...</text>
+          <text fg={theme().textMuted} wrapMode="wrap">"{note()}"</text>
+          <text fg={theme().textMuted}>Mapping to options — please wait</text>
+        </box>
+      </Show>
       <Show when={phase()==="feedback"}>
         <box flexDirection="column" gap={1} padding={1} border={true} borderColor={feedback()?.correct?theme().success:theme().error} backgroundColor={theme().background}>
           <For each={cur().options}>{(opt:any,i:any)=>{const id=i()+1; const sel=()=>feedback()?.selectedIndices.includes(id)??false; const ok=()=>new Set(cur().correctIndices).has(id); let ic=" "; let fg=theme().textMuted; let bg:any=undefined; if(dontKnow()){ic=ok()?"✓":" "; fg=ok()?theme().background:theme().textMuted; bg=ok()?theme().success:undefined} else if(sel()&&ok()){ic="✓"; fg=theme().background; bg=theme().success} else if(sel()&&!ok()){ic="✗"; fg=theme().background; bg=theme().error} else if(!sel()&&ok()){ic="○"; fg=theme().background; bg=theme().warning} return <box flexDirection="row" gap={1} paddingLeft={1} backgroundColor={bg}><box width={2}><text fg={fg} bold>{ic}</text></box><box flexGrow={1}><text fg={fg} wrapMode="wrap">{id}. {opt.label}</text></box></box>}}</For>
           <text fg={feedback()?.correct?theme().success:theme().error} bold>{feedback()?.correct?"✓ Correct":"✗ Incorrect"}</text>
           <text fg={theme().textMuted}>Correct: {cur().correctIndices.map((i:number)=>`${i}. ${cur().options[i-1]?.label}`).join(", ")}</text>
           <box border={true} borderColor={theme().borderSubtle} backgroundColor={theme().backgroundPanel} padding={1}><text fg={theme().text} wrapMode="wrap">{cur().explanation}</text></box>
-          <box justifyContent="center"><text fg={theme().textMuted}>Enter → next ({idx()+1}/{props.request.quizzes.length})</text></box>
         </box>
       </Show>
+      </scrollbox>
+      <box height={1} justifyContent="center">
+        <text fg={theme().textMuted}>
+          {phase()==="feedback" ? `Enter → next (${idx()+1}/${props.request.quizzes.length})` : phase()==="classifying" ? "Classifying your note..." : "Navigate options · Tab note · Esc cancel"}
+        </text>
+      </box>
     </box>
   )
 }
@@ -389,6 +552,7 @@ function QuizBatchDialog(props: {
 export const tui: TuiPlugin = async (api) => {
   const dir = api.state.path.directory || api.state.path.worktree || process.cwd()
   const pendingDir = path.join(dir, PENDING_DIR)
+  ;(globalThis as any).__learnPendingDir = pendingDir
   ensureDir(pendingDir)
   const heartbeatPath = path.join(pendingDir, ".tui-alive")
   try { fs.writeFileSync(heartbeatPath, String(Date.now()), "utf8") } catch {}
@@ -415,7 +579,7 @@ export const tui: TuiPlugin = async (api) => {
     if (current) return
     if (api.ui.dialog.open) return
     let files: string[] = []
-    try { files = fs.readdirSync(pendingDir).filter(f => f.endsWith(".json") && !f.startsWith("response-") && !f.startsWith(".")).sort() } catch { return }
+    try { files = fs.readdirSync(pendingDir).filter(f => f.endsWith(".json") && !f.startsWith("response-") && !f.startsWith(".") && !f.startsWith("classify")).sort() } catch { return }
     // Session-distinct: only show pending for current session
     const matching = files.map(f => { try { const j = JSON.parse(fs.readFileSync(path.join(pendingDir, f), "utf8")) as any; return { f, j } } catch { return null } }).filter(Boolean) as Array<{f: string, j: any}>
     const pick = matching.find(x => x.j.sessionID === curSid) || matching.find(x => !x.j.sessionID)
@@ -425,6 +589,7 @@ export const tui: TuiPlugin = async (api) => {
     let data: Pending | null = null
     try { data = JSON.parse(fs.readFileSync(full, "utf8")) as Pending } catch { try { fs.unlinkSync(full) } catch {}; return }
     if (!data || !data.id) { try { fs.unlinkSync(full) } catch {}; return }
+    if (!(data as any).sessionID) (data as any).sessionID = curSid
     // If pending was from a previous session that no longer exists, rebind to current session so inject still wakes you (like loop guardLoopOwnedUserMessage)
     try {
       const cur = (api.route as any)?.current

package/plugins/learn.ts

@@ -454,11 +454,164 @@ const server: Plugin = async ({ client, directory }) => {
   const loggedToolCallIds = new Set<string>()
   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[] {
+    const n = note.toLowerCase()
+    const out: 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)
+      else {
+        const tokens = label.split(/[^a-z0-9]+/).filter(t => t.length >= 3)
+        if (tokens.some(t => n.includes(t))) out.push(i + 1)
+      }
+    }
+    return [...new Set(out)]
+  }
+  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.
+
+${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.
+
+Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If vague/"I don't know", inferred:[], semanticCorrect:false. No markdown, just JSON.`
+    try {
+      const title = `classify: ${question ? question.slice(0, 30) : note.slice(0, 20)}`
+      const body: any = { title }
+      if (parentSessionID) body.parentID = parentSessionID
+      const created: any = await client.session.create({ body, query: { directory } })
+      const sid = created?.data?.id || created?.id || created?.data?.sessionID
+      if (!sid) throw new Error("no sid")
+      const createdSession = created?.data || created
+      slog("classify subagent created", sid, `requestedParent:${parentSessionID || "none"}`, `actualParent:${createdSession?.parentID || "none"}`, note.slice(0, 40))
+      if (parentSessionID && createdSession?.parentID !== parentSessionID) {
+        throw new Error(`classifier parent mismatch: expected ${parentSessionID}, got ${createdSession?.parentID || "none"}`)
+      }
+      await client.session.prompt({ path: { id: sid }, body: { parts: [{ type: "text", text: prompt }], agent: "classify" } })
+      // Poll for assistant response up to 12s
+      for (let i = 0; i < 24; i++) {
+        await new Promise(r => setTimeout(r, 500))
+        try {
+          const msgs: any = await client.session.messages({ path: { id: sid } })
+          const data = msgs?.data || msgs
+          const arr = Array.isArray(data) ? data : []
+          for (let j = arr.length - 1; j >= 0; j--) {
+            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(" ") || ""
+              // Try object JSON {"inferred":[2],"semanticCorrect":false}
+              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: 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 }
+                  }
+                } catch {}
+              }
+              const m = text.match(/\[[\s\d,]*\]/)
+              if (m) {
+                try {
+                  const parsed = JSON.parse(m[0])
+                  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 }
+                    }
+                  }
+                } 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 }
+              }
+            }
+          }
+        } catch {}
+      }
+      slog("llmClassify timeout", note.slice(0, 40))
+    } catch (e) {
+      slog("llmClassify failed", String(e).slice(0, 200))
+    }
+    return { inferred: [] }
+  }
+  function startClassifyWatcher(client: any, directory: string) {
+    const dir = pendingDir(directory)
+    try { fs.mkdirSync(dir, { recursive: true }) } catch {}
+    const processClassify = async (filename: string) => {
+      if (!filename.startsWith("classify-") || filename.startsWith("classify-response-")) return
+      const fp = path.join(dir, filename)
+      if (!fs.existsSync(fp)) return
+      const respPath = path.join(dir, filename.replace("classify-", "classify-response-"))
+      if (fs.existsSync(respPath)) return
+      let data: any
+      try { data = JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return }
+      if (data?.type !== "classify" || !data?.note || !Array.isArray(data?.options)) return
+      slog("classify watcher processing", data.id, data.note.slice(0, 80))
+      const byVal = new Map<string, number>(data.options.map((o: any, i: number) => [o.value, i + 1] as [string, number]))
+      const start = Date.now()
+      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)
+      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 || ""}`)
+      } else {
+        inferred = heuristicClassify(data.note, data.options)
+        if (inferred.length) slog("classify heuristic hit", data.id, inferred.join(","))
+        else slog("classify no match", data.id, `"${data.note.slice(0, 40)}"`)
+      }
+      // 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
+      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)
+          }
+        }
+      }
+      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} 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 {}
+    }
+    // Initial sweep
+    try {
+      for (const f of fs.readdirSync(dir).filter(f => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
+        void processClassify(f)
+      }
+    } catch {}
+    try {
+      const w = fs.watch(dir, (_e, filename) => { if (filename) void processClassify(filename) })
+      w.on("error", () => {})
+      // Keep watcher alive; store to avoid GC? No need.
+    } catch {}
+  }
+  startClassifyWatcher(client, directory)
+
   // Durability: on (re)start, re-watch any pending quizzes left from a crash/exit
   try {
     const dir = pendingDir(directory)
     if (fs.existsSync(dir)) {
-      for (const f of fs.readdirSync(dir).filter(x => x.endsWith(".json") && !x.startsWith("response-") && !x.startsWith("."))) {
+      for (const f of fs.readdirSync(dir).filter(x => x.endsWith(".json") && !x.startsWith("response-") && !x.startsWith(".") && !x.startsWith("classify"))) {
         try {
           const j = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"))
           if (j?.id && j?.sessionID) {
@@ -511,7 +664,7 @@ const server: Plugin = async ({ client, directory }) => {
     config: async (output) => {
       const agents = (output as any).agent ?? {}
       let mutated = false
-      for (const name of ["researcher", "mermaid-maker", "svg-maker"]) {
+      for (const name of ["researcher", "mermaid-maker", "svg-maker", "classify"]) {
         if (!agents[name]) {
           // Minimal placeholder — real agent definitions live in .opencode/agents/*.md
           // We inject a lightweight config so `task` tool can discover them even if md file is missing.

package/scripts/install.mjs

@@ -184,7 +184,7 @@ async function installOrUpdate() {
   const agentsSrc = join(root, "agents")
   const agentsDest = join(config, "agents")
   let agentsCount = 0
-  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md"]) {
+  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md", "classify.md"]) {
     try {
       await copyFile(join(agentsSrc, f), join(agentsDest, f))
       agentsCount++
@@ -216,7 +216,7 @@ async function installOrUpdate() {
 
   console.log(`Installed ${packageName}@${packageVersion} to ${config}`)
   if (changed) console.log(`Updated plugin registration in ${changed} config file(s)`)
-  console.log(`  Agents: ${agentsCount} (researcher, mermaid-maker, svg-maker)`)
+  console.log(`  Agents: ${agentsCount} (researcher, mermaid-maker, svg-maker, classify)`)
   console.log(`  Skills: ${skillsCount} (teach, visualize, marker-pdf-parser, notebooklm-lecture-notes)`)
   if (commandsCount) console.log(`  Commands: ${commandsCount}`)
   console.log(`  Plugin: ${packageName} (server) + ${packageName}/tui (TUI)`)
@@ -230,7 +230,7 @@ async function uninstall() {
   const changed = await configurePlugins(true)
 
   // Remove agents (only those we own)
-  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md"]) {
+  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md", "classify.md"]) {
     try { await rm(join(config, "agents", f), { force: true }) } catch {}
   }
   // Remove skills (including subdirectories like scripts/assets)