@bojackduy/opencode-learn 0.1.5 → 1.0.0

package/package.json

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

@@ -6,12 +6,66 @@ import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
 import * as fs from "node:fs"
 import * as path from "node:path"
 import { watch } from "node:fs"
+import { SyntaxStyle } from "@opentui/core"
+function syntaxStyle(theme:any){
+  return SyntaxStyle.fromTheme([
+    { scope: ["default"], style: { foreground: theme.text } },
+    { scope: ["comment", "comment.documentation"], style: { foreground: theme.syntaxComment, italic: true } },
+    { scope: ["string", "symbol", "character", "character.special"], style: { foreground: theme.syntaxString } },
+    { scope: ["number", "boolean", "float", "constant"], style: { foreground: theme.syntaxNumber } },
+    { scope: ["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine", "keyword", "keyword.directive", "keyword.modifier", "keyword.exception"], style: { foreground: theme.syntaxKeyword, italic: true } },
+    { scope: ["keyword.type"], style: { foreground: theme.syntaxType, bold: true, italic: true } },
+    { scope: ["keyword.import", "keyword.export", "tag.attribute"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["keyword.function", "function.method", "variable.member", "function", "constructor"], style: { foreground: theme.syntaxFunction } },
+    { scope: ["operator", "keyword.operator", "punctuation.delimiter", "keyword.conditional.ternary", "punctuation.special", "tag.delimiter"], style: { foreground: theme.syntaxOperator } },
+    { scope: ["variable", "variable.parameter", "function.method.call", "function.call", "property", "parameter", "field"], style: { foreground: theme.syntaxVariable } },
+    { scope: ["type", "module", "class", "namespace"], style: { foreground: theme.syntaxType } },
+    { scope: ["punctuation", "punctuation.bracket"], style: { foreground: theme.syntaxPunctuation } },
+    { scope: ["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super", "tag"], style: { foreground: theme.error } },
+    { scope: ["string.escape", "string.regexp"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["markup.heading"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.1"], style: { foreground: theme.markdownHeading, bold: true, underline: true } },
+    { scope: ["markup.bold", "markup.strong"], style: { foreground: theme.markdownStrong, bold: true } },
+    { scope: ["markup.italic"], style: { foreground: theme.markdownEmph, italic: true } },
+    { scope: ["markup.list"], style: { foreground: theme.markdownListItem } },
+    { scope: ["markup.quote"], style: { foreground: theme.markdownBlockQuote, italic: true } },
+    { scope: ["markup.raw", "markup.raw.block"], style: { foreground: theme.markdownCode } },
+    { scope: ["markup.raw.inline"], style: { foreground: theme.markdownCode, background: theme.background } },
+    { scope: ["markup.link", "markup.link.url", "string.special", "string.special.url"], style: { foreground: theme.markdownLink, underline: true } },
+    { scope: ["markup.link.label", "label"], style: { foreground: theme.markdownLinkText, underline: true } },
+    { scope: ["spell", "nospell", "markup.underline"], style: { foreground: theme.text } },
+    { scope: ["conceal", "markup.strikethrough", "markup.list.unchecked", "debug"], style: { foreground: theme.textMuted } },
+    { scope: ["comment.error", "error"], style: { foreground: theme.error, italic: true, bold: true } },
+    { scope: ["comment.warning", "warning"], style: { foreground: theme.warning, italic: true, bold: true } },
+    { scope: ["comment.todo", "comment.note"], style: { foreground: theme.info, italic: true, bold: true } },
+    { scope: ["type.definition"], style: { foreground: theme.syntaxType, bold: true } },
+    { scope: ["attribute", "annotation"], style: { foreground: theme.warning } },
+    { scope: ["markup.list.checked"], style: { foreground: theme.success } },
+    { scope: ["diff.plus"], style: { foreground: theme.diffAdded, background: theme.diffAddedBg } },
+    { scope: ["diff.minus"], style: { foreground: theme.diffRemoved, background: theme.diffRemovedBg } },
+    { scope: ["diff.delta"], style: { foreground: theme.diffContext, background: theme.diffContextBg } },
+    { scope: ["info"], style: { foreground: theme.info } },
+  ])
+}
 
 const PENDING_DIR = ".opencode/learn-pending"
 import { tmpdir } from "node:os"
 const TUI_LOG = path.join(tmpdir(), "learn-tui.log")
 function tlog(...a: any[]) { try { fs.appendFileSync(TUI_LOG, `[${new Date().toISOString()}] ${a.map(x=> typeof x==="string"? x : JSON.stringify(x)).join(" ")}\n`) } catch {} }
 function ensureDir(dir: string) { try { fs.mkdirSync(dir, { recursive: true }) } catch {} }
+function decodeQuizText(s: string): string {
+  if (!s || typeof s !== "string") return s
+  if (!s.includes("\\")) return s
+  // Convert literal \n / \r\n / \t escapes to real whitespace. Handles both single and double-escaped payloads (e.g. file contains \\n after JSON round-trip).
+  // Only touches backslash sequences, leaves actual newlines intact.
+  let out = s.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "\t")
+  // Decode escaped quotes/backslashes that may survive double-escaping: \" -> ", \' -> ', \\ -> \
+  // Do this after newline handling to avoid re-introducing \n.
+  out = out.replace(/\\"/g, '"').replace(/\\'/g, "'")
+  // Collapse double-escaped backslashes that are not part of \n already handled
+  out = out.replace(/\\\\/g, "\\")
+  return out
+}
 
 type QuizPending = {
   id: string
@@ -22,6 +76,7 @@ type QuizPending = {
   correctIndices: number[]
   explanation: string
   multiSelect?: boolean
+  sessionID?: string
   timestamp: number
 }
 type QuizBatchPending = {
@@ -42,8 +97,10 @@ function QuizDialog(props: {
   onCancel: () => void
 }) {
   const theme = () => props.api.theme.current
+  const syntax = () => syntaxStyle(theme())
   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,19 +109,45 @@ 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())
   const [feedback, setFeedback] = createSignal<{ correct: boolean; selectedIndices: number[] } | null>(null)
 
   let noteInputEl: any
-
+  let scrollRef: any
+  const [canScrollUp, setCanScrollUp] = createSignal(false)
+  const [canScrollDown, setCanScrollDown] = createSignal(false)
+  const updateScrollIndicators = () => {
+    try {
+      if (!scrollRef) { setCanScrollUp(false); setCanScrollDown(false); return }
+      const st = typeof scrollRef.scrollTop === "number" ? scrollRef.scrollTop : 0
+      const h = typeof scrollRef.height === "number" ? scrollRef.height : (scrollRef.viewportHeight ?? popupHeight())
+      const sh = typeof scrollRef.scrollHeight === "number" ? scrollRef.scrollHeight : 0
+      let effectiveSh = sh
+      if (!effectiveSh && typeof scrollRef.getChildren === "function") {
+        try { const kids = scrollRef.getChildren(); if (kids?.length) effectiveSh = Math.max(...kids.map((c:any)=> (c.y||0)+(c.height||0)), h) } catch {}
+      }
+      if (!effectiveSh || effectiveSh <= h + 1) { setCanScrollUp(false); setCanScrollDown(false); return }
+      setCanScrollUp(st > 0)
+      setCanScrollDown(st + h < effectiveSh - 1)
+    } catch { setCanScrollUp(false); setCanScrollDown(false) }
+  }
+  const scrollAmount = () => Math.max(1, Math.floor((scrollRef?.height ?? popupHeight()) / 3))
   createEffect(() => {
     if (focused() === "note" && noteInputEl) {
       try { noteInputEl.focus() } catch {}
     }
   })
+  // Keep indicators in sync on phase/dims/feedback changes
+  createEffect(() => { phase(); feedback(); dims(); setTimeout(updateScrollIndicators, 40); setTimeout(updateScrollIndicators, 200) })
+  createEffect(() => { note(); setTimeout(updateScrollIndicators, 40) })
+  createEffect(() => {
+    if (phase() !== "feedback" && phase() !== "select") return
+    const id = setInterval(updateScrollIndicators, 200)
+    onCleanup(() => clearInterval(id))
+  })
 
   const toggleOption = (idx: number) => {
     const opt = options()[idx]
@@ -86,8 +169,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")
@@ -105,12 +251,28 @@ function QuizDialog(props: {
     props.onSubmit({ answers: dontKnow() ? [] : sel, dontKnow: dontKnow(), note: note().trim() || undefined })
   }
 
+  const isPlainKey = (evt:any, want:string) => {
+    try {
+      const n = String(evt.name||evt.sequence||"").toLowerCase()
+      if (n !== want.toLowerCase()) return false
+      if (evt.ctrl || evt.meta || evt.option || evt.alt) return false
+      return true
+    } catch { return false }
+  }
   useKeyboard((evt: any) => {
     const key = evt.name || evt.sequence || evt.raw || ""
     const seq = evt.sequence || ""
-    // When in feedback, any Enter/Esc confirms
+    const lower = String(key||"").toLowerCase()
+    if ((phase() as any) === "classifying") { prevent(evt); return }
+    // When in feedback, handle scroll first, then confirm
     if (phase() === "feedback") {
-      if (key === "enter" || seq === "\r" || key === "escape" || key === "esc") {
+      if (isPlainKey(evt,"d") || seq === "\x04") { prevent(evt); try { scrollRef?.scrollBy(scrollAmount()); setTimeout(updateScrollIndicators, 30); setTimeout(updateScrollIndicators, 120) } catch {} return }
+      if (isPlainKey(evt,"u") || seq === "\x15") { prevent(evt); try { scrollRef?.scrollBy(-scrollAmount()); setTimeout(updateScrollIndicators, 30); setTimeout(updateScrollIndicators, 120) } catch {} return }
+      if (isPlainKey(evt,"j") || seq === "\x1b[B") { prevent(evt); try { scrollRef?.scrollBy(1); setTimeout(updateScrollIndicators, 30) } catch {} return }
+      if (isPlainKey(evt,"k") || seq === "\x1b[A") { prevent(evt); try { scrollRef?.scrollBy(-1); setTimeout(updateScrollIndicators, 30) } catch {} return }
+      if (key === "pageup" || seq === "\x1b[5~") { prevent(evt); try { scrollRef?.scrollBy(-scrollAmount()); setTimeout(updateScrollIndicators, 30) } catch {} return }
+      if (key === "pagedown" || seq === "\x1b[6~") { prevent(evt); try { scrollRef?.scrollBy(scrollAmount()); setTimeout(updateScrollIndicators, 30) } catch {} return }
+      if ( lower === "enter" || seq === "\r" || lower === "escape" || lower === "esc") {
         prevent(evt)
         confirmFeedback()
       }
@@ -124,15 +286,26 @@ function QuizDialog(props: {
       // Allow typing to go to input; don't prevent
       return
     }
-    // Options focused
+    // d/u scroll works in both select and feedback — page scroll even before answer
+    if (phase() === "select" && (isPlainKey(evt,"d") || seq === "\x04")) { prevent(evt); try { scrollRef?.scrollBy(scrollAmount()); setTimeout(updateScrollIndicators,30); setTimeout(updateScrollIndicators,120) } catch {} return }
+    if (phase() === "select" && (isPlainKey(evt,"u") || seq === "\x15")) { prevent(evt); try { scrollRef?.scrollBy(-scrollAmount()); setTimeout(updateScrollIndicators,30); setTimeout(updateScrollIndicators,120) } catch {} return }
+    if (phase() === "select" && (lower === "pageup" || seq === "\x1b[5~")) { prevent(evt); try { scrollRef?.scrollBy(-scrollAmount()); setTimeout(updateScrollIndicators,30) } catch {} return }
+    if (phase() === "select" && (lower === "pagedown" || seq === "\x1b[6~")) { prevent(evt); try { scrollRef?.scrollBy(scrollAmount()); setTimeout(updateScrollIndicators,30) } catch {} return }
+    // 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 +319,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,18 +333,19 @@ 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>
 
-        {/* Question */}
+        <scrollbox ref={(el:any)=> scrollRef = el} flexGrow={1} verticalScrollbarOptions={{ visible: true, trackOptions: { backgroundColor: theme().background, foregroundColor: theme().borderActive } }}>
+        {/* Question — use opencode markdown render so ```python blocks get syntax coloring like native messages */}
         <box flexDirection="column" gap={1} paddingLeft={1} paddingRight={1} paddingTop={1}>
-          <text fg={theme().text} bold wrapMode="wrap">{props.request.question}</text>
+          <markdown syntaxStyle={syntax()} content={decodeQuizText(props.request.question)} fg={theme().text} bg={theme().backgroundPanel} />
           <Show when={props.request.details}>
-            <text fg={theme().textMuted} wrapMode="wrap">{props.request.details}</text>
+            <markdown syntaxStyle={syntax()} content={decodeQuizText(props.request.details)} fg={theme().textMuted} bg={theme().backgroundPanel} />
           </Show>
         </box>
 
@@ -208,25 +383,43 @@ 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}>{isMulti() ? `${selected().size} selected${dontKnow() ? " · I don't know" : ""}` : note().trim() && !selected().size && !dontKnow() ? "note → classify" : dontKnow() ? "I don't know" : ""}</text>
+              <text fg={theme().textMuted}>{focused() === "note" ? "Tab/Esc back" : ""}</text>
             </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>
 
@@ -258,11 +451,24 @@ function QuizDialog(props: {
             <text fg={theme().textMuted}>Correct: {props.request.correctIndices.map(i => `${i}. ${options()[i-1]?.label}`).join(", ")}</text>
             <Show when={note()}><text fg={theme().textMuted}>Your note: {note()}</text></Show>
             <box border={true} borderColor={theme().borderSubtle} backgroundColor={theme().backgroundPanel} padding={1}>
-              <text fg={theme().text} wrapMode="wrap">{props.request.explanation}</text>
+              <markdown syntaxStyle={syntax()} content={decodeQuizText(props.request.explanation)} fg={theme().text} bg={theme().backgroundPanel} />
             </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} wrapMode="wrap">
+            {phase() === "feedback"
+              ? (canScrollUp() && canScrollDown() ? "▲ more above · ▼ more below — d/u to scroll · Enter to continue"
+                : canScrollDown() ? "▼ more below — d to scroll · Enter to continue"
+                : canScrollUp() ? "▲ more above — u to scroll · Enter to continue"
+                : "↵ Enter / Esc to continue  →  next probe")
+              : phase() === "classifying" ? "Classifying your note..."
+              : focused() === "note" ? "Enter submit note → classify · Tab/Esc back"
+              : (canScrollUp() || canScrollDown()) ? "j/k or ↑↓ move · Space toggle · Tab note · Enter submit · Esc cancel · d/u scroll"
+              : "j/k or ↑↓ move · Space toggle · Tab note · Enter submit · Esc cancel"}
+          </text>
+        </box>
       </box>
   )
 }
@@ -275,8 +481,10 @@ function QuizBatchDialog(props: {
   onCancel: () => void
 }) {
   const theme = () => props.api.theme.current
+  const syntax = () => syntaxStyle(theme())
   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 +493,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())
@@ -297,7 +505,33 @@ function QuizBatchDialog(props: {
   const dontKnowIdx = () => cur().options.length
   const submitIdx = () => isMulti() ? cur().options.length + 1 : -1
   let noteEl: any
+  let scrollRefBatch: any
+  const [canScrollUpBatch, setCanScrollUpBatch] = createSignal(false)
+  const [canScrollDownBatch, setCanScrollDownBatch] = createSignal(false)
+  const updateScrollBatch = () => {
+    try {
+      if (!scrollRefBatch) { setCanScrollUpBatch(false); setCanScrollDownBatch(false); return }
+      const st = typeof scrollRefBatch.scrollTop === "number" ? scrollRefBatch.scrollTop : 0
+      const h = typeof scrollRefBatch.height === "number" ? scrollRefBatch.height : (scrollRefBatch.viewportHeight ?? popupHeight())
+      const sh = typeof scrollRefBatch.scrollHeight === "number" ? scrollRefBatch.scrollHeight : 0
+      let effectiveSh = sh
+      if (!effectiveSh && typeof scrollRefBatch.getChildren === "function") {
+        try { const kids = scrollRefBatch.getChildren(); if (kids?.length) effectiveSh = Math.max(...kids.map((c:any)=> (c.y||0)+(c.height||0)), h) } catch {}
+      }
+      if (!effectiveSh || effectiveSh <= h + 1) { setCanScrollUpBatch(false); setCanScrollDownBatch(false); return }
+      setCanScrollUpBatch(st > 0)
+      setCanScrollDownBatch(st + h < effectiveSh - 1)
+    } catch { setCanScrollUpBatch(false); setCanScrollDownBatch(false) }
+  }
+  const scrollAmountBatch = () => Math.max(1, Math.floor((scrollRefBatch?.height ?? popupHeight()) / 3))
   createEffect(() => { if (focused()==="note" && noteEl) try{noteEl.focus()}catch(e){ tlog("note focus failed", String(e)) } })
+  createEffect(() => { phase(); feedback(); dims(); idx(); setTimeout(updateScrollBatch, 40); setTimeout(updateScrollBatch, 200) })
+  createEffect(() => { note(); setTimeout(updateScrollBatch, 40) })
+  createEffect(() => {
+    if (phase() !== "feedback" && phase() !== "select") return
+    const id = setInterval(updateScrollBatch, 200)
+    onCleanup(() => clearInterval(id))
+  })
   const toggle = (i:number) => {
     try {
       const o = cur().options[i]; if(!o) return
@@ -329,8 +563,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)
@@ -341,11 +625,22 @@ function QuizBatchDialog(props: {
       setPhase("feedback")
     } catch(e){ tlog("submitSelect failed", String(e)) }
   }
+  const isPlainKeyBatch = (evt:any, want:string) => {
+    try { const n=String(evt.name||evt.sequence||"").toLowerCase(); if(n!==want.toLowerCase()) return false; if(evt.ctrl||evt.meta||evt.option||evt.alt) return false; return true } catch { return false }
+  }
   useKeyboard((evt:any)=>{
     try {
-      const k=evt.name||evt.sequence||evt.raw||""; const seq=evt.sequence||""
-      if(phase()==="feedback"){ if(k==="enter"||seq==="\r"||k==="escape"||k==="esc"){ prevent(evt); goNext() } return }
+      const k=evt.name||evt.sequence||evt.raw||""; const seq=evt.sequence||""; const lower=String(k||"").toLowerCase()
+      if((phase() as any)==="classifying"){ prevent(evt); return }
+      if(phase()==="feedback"){
+        if (isPlainKeyBatch(evt,"d")||seq==="\x04"){ prevent(evt); try{scrollRefBatch?.scrollBy(scrollAmountBatch()); setTimeout(updateScrollBatch,30); setTimeout(updateScrollBatch,120)}catch{} return }
+        if (isPlainKeyBatch(evt,"u")||seq==="\x15"){ prevent(evt); try{scrollRefBatch?.scrollBy(-scrollAmountBatch()); setTimeout(updateScrollBatch,30); setTimeout(updateScrollBatch,120)}catch{} return }
+        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(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}
@@ -356,32 +651,45 @@ 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>
-      <text fg={theme().text} bold wrapMode="wrap">{cur().question}</text>
-      <Show when={cur().details}><text fg={theme().textMuted} wrapMode="wrap">{cur().details}</text></Show>
+      <scrollbox ref={(el:any)=> scrollRefBatch = el} flexGrow={1} verticalScrollbarOptions={{ visible: true, trackOptions: { backgroundColor: theme().background, foregroundColor: theme().borderActive } }}>
+      <markdown syntaxStyle={syntax()} content={decodeQuizText(cur().question)} fg={theme().text} bg={theme().backgroundPanel} />
+      <Show when={cur().details}><markdown syntaxStyle={syntax()} content={decodeQuizText(cur().details)} fg={theme().textMuted} bg={theme().backgroundPanel} /></Show>
       <Show when={phase()==="select"}>
         <box flexDirection="column" gap={0} padding={1} border={true} borderColor={theme().borderSubtle} backgroundColor={theme().background}>
           <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}>{isMulti() ? `${selected().size} selected` : note().trim() && !selected().size ? "note → classify" : ""}</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 border={true} borderColor={theme().borderSubtle} backgroundColor={theme().backgroundPanel} padding={1}><markdown syntaxStyle={syntax()} content={decodeQuizText(cur().explanation)} fg={theme().text} bg={theme().backgroundPanel} /></box>
         </box>
       </Show>
+      </scrollbox>
+      <box height={1} justifyContent="center">
+        <text fg={theme().textMuted} wrapMode="wrap">
+          {phase()==="feedback" ? (canScrollUpBatch() && canScrollDownBatch() ? `▲ more above · ▼ more below — d/u to scroll · Enter → next (${idx()+1}/${props.request.quizzes.length})` : canScrollDownBatch() ? `▼ more below — d to scroll · Enter → next (${idx()+1}/${props.request.quizzes.length})` : canScrollUpBatch() ? `▲ more above — u to scroll · Enter → next (${idx()+1}/${props.request.quizzes.length})` : `Enter → next (${idx()+1}/${props.request.quizzes.length})`) : phase()==="classifying" ? "Classifying your note..." : focused()==="note" ? "Enter submit note → classify · Tab/Esc back" : (canScrollUpBatch() || canScrollDownBatch()) ? "j/k or ↑↓ move · Space toggle · Tab note · Enter submit · Esc cancel · d/u scroll" : "j/k or ↑↓ move · Space toggle · Tab note · Enter submit · Esc cancel"}
+        </text>
+      </box>
     </box>
   )
 }
@@ -389,6 +697,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 +724,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 +734,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