@bojackduy/opencode-learn 1.2.2 → 1.2.4

package/dist/server.js

@@ -317,6 +317,20 @@ function answerCalloutQuiz(details) {
   }
   return callout(type, title, body);
 }
+function answerCalloutQuestion(questions, answers) {
+  const qs = Array.isArray(questions) ? questions : [];
+  const ans = Array.isArray(answers) ? answers : [];
+  if (!qs.length) {
+    const flat = ans.map((a) => Array.isArray(a) ? a.join(", ") : String(a ?? "")).filter(Boolean);
+    return callout("example", "Answer", flat.length ? flat : ["(no answer)"]);
+  }
+  const body = qs.map((q, i) => {
+    const header = q?.header || `Q${i + 1}`;
+    const sel = Array.isArray(ans[i]) ? ans[i] : [];
+    return `${header}: ${sel.length ? sel.join(", ") : "(no answer)"}`;
+  });
+  return callout("example", "Answer", body);
+}
 function answerCalloutAsk(details) {
   const status = details?.status;
   if (status === "cancelled")
@@ -324,11 +338,17 @@ function answerCalloutAsk(details) {
   if (status === "unavailable")
     return callout("warning", "Question \u2014 unavailable", [details?.message || ""]);
   const answers = details?.answers || [];
+  if (answers.length && answers.every((a) => Array.isArray(a))) {
+    const questions = details?.questions || [];
+    return answerCalloutQuestion(questions, answers);
+  }
   const body = answers.map((a) => {
     if (a.type === "other")
       return `Other: ${a.label}`;
     if (a.type === "text")
       return a.label;
+    if (typeof a === "string")
+      return a;
     return `${a.index}. ${a.label}`;
   });
   if (body.length === 0)
@@ -401,6 +421,25 @@ async function backfillMdLog(client, sessionID, directory) {
             }
             continue;
           }
+          if (toolName === "question" && Array.isArray(input.questions)) {
+            const qs = input.questions;
+            if (st.status === "pending" || st.status === "running") {
+              qs.forEach((q, i) => {
+                if (!q?.question)
+                  return;
+                blocks.push(questionCallout(q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question"), q.question, undefined, q.options ?? []));
+              });
+            } else if (st.status === "completed") {
+              qs.forEach((q, i) => {
+                if (!q?.question)
+                  return;
+                blocks.push(questionCallout(q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question"), q.question, undefined, q.options ?? []));
+              });
+              const ans = Array.isArray(meta.answers) ? meta.answers : [];
+              blocks.push(answerCalloutAsk({ answers: ans, questions: qs, status: "completed" }));
+            }
+            continue;
+          }
           if (st.status === "pending" || st.status === "running") {
             if (input.question) {
               const opts = Array.isArray(input.options) ? input.options : [];
@@ -492,26 +531,57 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
   }
   const dir = pendingDir(directory);
   const respPath = path.join(dir, `response-${id}.json`);
-  const fire = async () => {
-    let data;
+  const claimPath = path.join(dir, `response-${id}.claim-${process.pid}.json`);
+  const pendingCandidates = [path.join(dir, `quiz-${id}.json`), path.join(dir, `quiz_batch-${id}.json`)];
+  const closeWatcher = () => {
+    const w = activeWatchers.get(id);
+    if (w) {
+      try {
+        w.close();
+      } catch {}
+      activeWatchers.delete(id);
+    }
+  };
+  const fire = async (attempt = 0) => {
     try {
-      data = JSON.parse(fs.readFileSync(respPath, "utf8"));
+      fs.renameSync(respPath, claimPath);
     } catch {
+      closeWatcher();
       return;
     }
+    let data;
     try {
-      fs.unlinkSync(respPath);
-    } catch {}
-    const w = activeWatchers.get(id);
-    if (w) {
+      data = JSON.parse(fs.readFileSync(claimPath, "utf8"));
+    } catch (e) {
+      if (attempt < 5) {
+        await new Promise((r) => setTimeout(r, 120));
+        try {
+          fs.renameSync(claimPath, respPath);
+        } catch {}
+        await new Promise((r) => setTimeout(r, 60));
+        return fire(attempt + 1);
+      }
+      slog("watchAndInject UNREADABLE response, parked", id, String(e).slice(0, 160));
       try {
-        w.close();
+        fs.renameSync(claimPath, path.join(dir, `response-${id}.poisoned-${Date.now()}.json`));
       } catch {}
-      activeWatchers.delete(id);
+      closeWatcher();
+      return;
+    }
+    let text;
+    let effectiveSessionID;
+    try {
+      slog("watchAndInject fire", id, JSON.stringify(data).slice(0, 400));
+      effectiveSessionID = data?.sessionID || sessionID;
+      text = data?.cancelled ? `[cancelled] user dismissed the popup for ${id}` : buildText(data.result);
+    } catch (e) {
+      slog("watchAndInject buildText ERROR, parked", id, String(e).slice(0, 200));
+      try {
+        fs.renameSync(claimPath, path.join(dir, `response-${id}.poisoned-${Date.now()}.json`));
+      } catch {}
+      closeWatcher();
+      return;
     }
-    slog("watchAndInject fire", id, JSON.stringify(data).slice(0, 400));
-    const effectiveSessionID = data?.sessionID || sessionID;
-    const text = data?.cancelled ? `[cancelled] user dismissed the popup for ${id}` : buildText(data.result);
     const sdkCall = async (method, ...argsList) => {
       let firstErr;
       for (const args of argsList) {
@@ -537,35 +607,60 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
     ];
     slog("watchAndInject injecting", id, effectiveSessionID, text.slice(0, 300));
     let ok = false;
+    let firstErr;
     if (client?.session?.promptAsync) {
       try {
         await sdkCall(client.session.promptAsync.bind(client.session), ...shapes);
         ok = true;
-      } catch {}
+      } catch (e) {
+        firstErr = e;
+      }
     }
     if (!ok && client?.session?.prompt) {
       try {
         await sdkCall(client.session.prompt.bind(client.session), ...shapes);
         ok = true;
+      } catch (e) {
+        firstErr = firstErr || e;
+      }
+    }
+    if (!ok) {
+      slog("watchAndInject inject FAILED, preserved", id, effectiveSessionID, String(firstErr).slice(0, 200));
+      try {
+        fs.renameSync(claimPath, path.join(dir, `response-${id}.failed-${Date.now()}.json`));
+      } catch {}
+      try {
+        await client.app.log({ body: { service: "learn", level: "error", message: `inject FAILED for ${effectiveSessionID} (orig ${sessionID})`, extra: { id } } });
       } catch {}
+      closeWatcher();
+      return;
     }
     try {
-      await client.app.log({ body: { service: "learn", level: ok ? "info" : "error", message: ok ? `injected into ${effectiveSessionID}` : `inject FAILED for ${effectiveSessionID} (orig ${sessionID})`, extra: { id } } });
+      fs.unlinkSync(claimPath);
+    } catch {}
+    for (const p of pendingCandidates)
+      try {
+        fs.unlinkSync(p);
+      } catch {}
+    closeWatcher();
+    slog("watchAndInject consumed", id, effectiveSessionID);
+    try {
+      await client.app.log({ body: { service: "learn", level: "info", message: `injected into ${effectiveSessionID}`, extra: { id } } });
     } catch {}
   };
-  if (fs.existsSync(respPath)) {
-    slog("watchAndInject fast-path", id);
-    fire();
-    return;
-  }
   try {
     const w = fs.watch(dir, (_e, filename) => {
-      if (filename === `response-${id}.json` && fs.existsSync(respPath))
+      if (filename === `response-${id}.json`)
         fire();
     });
     w.on("error", () => {});
     activeWatchers.set(id, w);
   } catch {}
+  if (fs.existsSync(respPath)) {
+    slog("watchAndInject fast-path", id);
+    fire();
+    return;
+  }
 }
 var server = async ({ client, directory }) => {
   const markerPath = path.join(directory, ".opencode", "learn-md-log.json");
@@ -823,6 +918,20 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
   try {
     const dir = pendingDir(directory);
     if (fs.existsSync(dir)) {
+      for (const f of fs.readdirSync(dir).filter((x) => x.includes(".claim-") && x.endsWith(".json"))) {
+        try {
+          const m = f.match(/^response-(.+)\.claim-.*\.json$/);
+          if (!m)
+            continue;
+          const rid = m[1];
+          const target = path.join(dir, `response-${rid}.json`);
+          const age = Date.now() - fs.statSync(path.join(dir, f)).mtimeMs;
+          if (age > 30000 && !fs.existsSync(target)) {
+            fs.renameSync(path.join(dir, f), target);
+            slog("watchAndInject requeued stale claim", rid);
+          }
+        } catch {}
+      }
       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"));
@@ -879,6 +988,19 @@ Explanation: ${j.explanation}${note}`;
           }
         } catch {}
       }
+      for (const f of fs.readdirSync(dir).filter((x) => x.startsWith("response-") && x.endsWith(".json") && !x.includes(".claim-") && !x.includes(".poisoned") && !x.includes(".failed") && !x.includes(".orphaned"))) {
+        try {
+          const m = f.match(/^response-(.+)\.json$/);
+          if (!m)
+            continue;
+          const rid = m[1];
+          const hasPending = fs.existsSync(path.join(dir, `quiz-${rid}.json`)) || fs.existsSync(path.join(dir, `quiz_batch-${rid}.json`));
+          if (!hasPending) {
+            fs.renameSync(path.join(dir, f), path.join(dir, `response-${rid}.orphaned-${Date.now()}.json`));
+            slog("watchAndInject orphaned response parked (no pending context)", rid);
+          }
+        } catch {}
+      }
     }
   } catch {}
   return {
@@ -943,26 +1065,29 @@ Explanation: ${j.explanation}${note}`;
         await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, assistantBlock(stripSkillBlocks(text))));
       } catch {}
     },
-    "tool.execute.before": async (input) => {
+    "tool.execute.before": async (input, output) => {
       try {
         const ses = extractHookSessionID(input?.sessionID);
         const mdFile = getMdFile(ses);
         if (!mdFile || !ses)
           return;
         const toolName = input.tool;
-        const args = input.args ?? {};
+        const args = output?.args ?? input.args ?? {};
         if (toolName === "question") {
-          const q = args.question || args.header || "";
-          const ctx2 = args.details?.trim() || undefined;
-          const opts = Array.isArray(args.options) ? args.options : [];
           const callID = input.callID;
           const qkey = callID ? mdKey(ses, `q:${callID}`) : undefined;
           if (qkey && loggedToolCallIds.has(qkey))
             return;
           if (qkey)
             loggedToolCallIds.add(qkey);
-          if (q)
-            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, questionCallout("Question", q, ctx2, opts)));
+          const qs = Array.isArray(args.questions) ? args.questions : args.question ? [{ question: args.question, header: args.header, options: args.options ?? [] }] : [];
+          for (let i = 0;i < qs.length; i++) {
+            const q = qs[i];
+            if (!q?.question)
+              continue;
+            const label = q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question");
+            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, questionCallout(label, q.question, undefined, q.options ?? [])));
+          }
         }
       } catch {}
     },
@@ -978,11 +1103,21 @@ Explanation: ${j.explanation}${note}`;
         if (akey && loggedToolCallIds.has(akey))
           return;
         if (toolName === "question") {
-          const meta = output.metadata ?? {};
-          let answers = meta.answers ?? [];
-          if (!answers.length && output.output)
+          const meta = output?.metadata ?? {};
+          const inArgs = input?.args ?? {};
+          const qs = Array.isArray(inArgs.questions) ? inArgs.questions : [];
+          let answers = meta.answers;
+          if (!Array.isArray(answers) || !answers.length) {
+            const outText = typeof output?.output === "string" ? output.output.trim() : "";
+            if (outText) {
+              await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, callout("example", "Answer", [outText.slice(0, 500)])));
+              if (akey)
+                loggedToolCallIds.add(akey);
+              return;
+            }
             answers = [];
-          const details = { answers, status: "completed" };
+          }
+          const details = { answers, questions: qs, status: "completed" };
           await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, answerCalloutAsk(details)));
           if (akey)
             loggedToolCallIds.add(akey);

package/dist/tui.js

@@ -237,6 +237,17 @@ function ensureDir(dir) {
     });
   } catch {}
 }
+function writeJsonAtomic(filePath, data) {
+  try {
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+    fs.writeFileSync(tmp, JSON.stringify(data), "utf8");
+    fs.renameSync(tmp, filePath);
+  } catch {
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(data), "utf8");
+    } catch {}
+  }
+}
 function decodeQuizText(s) {
   if (!s || typeof s !== "string")
     return s;
@@ -391,7 +402,7 @@ function QuizDialog(props) {
           timestamp: Date.now(),
           sessionID: props.request.sessionID || routeSessionID
         };
-        fs.writeFileSync(path.join(pDir, `classify-${props.request.id}.json`), JSON.stringify(pendingClassify), "utf8");
+        writeJsonAtomic(path.join(pDir, `classify-${props.request.id}.json`), pendingClassify);
         tlog("QuizDialog classify request", props.request.id, note().trim().slice(0, 50));
         const respPath = path.join(pDir, `classify-response-${props.request.id}.json`);
         let attempts = 0;
@@ -1673,7 +1684,7 @@ function QuizBatchDialog(props) {
             timestamp: Date.now(),
             sessionID: props.request.sessionID || routeSessionID
           };
-          fs.writeFileSync(path.join(pDir, `classify-${cid}.json`), JSON.stringify(pendingClassify), "utf8");
+          writeJsonAtomic(path.join(pDir, `classify-${cid}.json`), pendingClassify);
           tlog("QuizBatchDialog classify request", cid, note().trim().slice(0, 50));
           const respPath = path.join(pDir, `classify-response-${cid}.json`);
           let attempts = 0;
@@ -2642,7 +2653,13 @@ var tui = async (api) => {
       } catch {
         return null;
       }
-    }).filter(Boolean);
+    }).filter(Boolean).filter((x) => {
+      try {
+        return !fs.existsSync(path.join(pendingDir, `response-${x.j.id}.json`));
+      } catch {
+        return true;
+      }
+    });
     const pick = matching.find((x) => x.j.sessionID === curSid) || matching.find((x) => !x.j.sessionID);
     if (!pick)
       return;
@@ -2682,15 +2699,15 @@ var tui = async (api) => {
     currentBySession.set(curSid, current);
     const done = async (result) => {
       const respPath = path.join(pendingDir, `response-${data.id}.json`);
-      try {
-        fs.writeFileSync(respPath, JSON.stringify({
-          id: data.id,
-          type: data.type,
-          result,
-          sessionID: data.sessionID,
-          at: Date.now()
-        }), "utf8");
-      } catch {}
+      const answerId = data.id;
+      tlog("learn-tui answered", data.type, answerId, JSON.stringify(result).slice(0, 160));
+      writeJsonAtomic(respPath, {
+        id: data.id,
+        type: data.type,
+        result,
+        sessionID: data.sessionID,
+        at: Date.now()
+      });
       try {
         const sessionID = data.sessionID;
         let injectText = "";
@@ -2780,24 +2797,30 @@ var tui = async (api) => {
           }
         }
       } catch {}
-      try {
-        fs.unlinkSync(full);
-      } catch {}
       api.ui.dialog.clear();
       currentBySession.delete(curSid);
       setTimeout(processPending, 150);
+      setTimeout(() => {
+        try {
+          if (fs.existsSync(respPath)) {
+            tlog("learn-tui response NOT consumed, re-touching", answerId);
+            try {
+              writeJsonAtomic(respPath, JSON.parse(fs.readFileSync(respPath, "utf8")));
+            } catch {}
+          }
+        } catch {}
+      }, 8000);
     };
     const cancel = async () => {
       const respPath = path.join(pendingDir, `response-${data.id}.json`);
-      try {
-        fs.writeFileSync(respPath, JSON.stringify({
-          id: data.id,
-          type: data.type,
-          cancelled: true,
-          sessionID: data.sessionID,
-          at: Date.now()
-        }), "utf8");
-      } catch {}
+      tlog("learn-tui cancelled", data.type, data.id);
+      writeJsonAtomic(respPath, {
+        id: data.id,
+        type: data.type,
+        cancelled: true,
+        sessionID: data.sessionID,
+        at: Date.now()
+      });
       try {
         const sid = data.sessionID;
         if (sid) {
@@ -2833,9 +2856,6 @@ var tui = async (api) => {
           } catch {}
         }
       } catch {}
-      try {
-        fs.unlinkSync(full);
-      } catch {}
       api.ui.dialog.clear();
       currentBySession.delete(curSid);
       setTimeout(processPending, 150);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "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": "AGPL-3.0-or-later",

package/plugins/learn-tui.tsx

@@ -53,6 +53,14 @@ 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 writeJsonAtomic(filePath: string, data: any) {
+  // Atomic handoff: readers never observe partial JSON (tmp + rename is atomic on POSIX)
+  try {
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`
+    fs.writeFileSync(tmp, JSON.stringify(data), "utf8")
+    fs.renameSync(tmp, filePath)
+  } catch { try { fs.writeFileSync(filePath, JSON.stringify(data), "utf8") } catch {} }
+}
 function decodeQuizText(s: string): string {
   if (!s || typeof s !== "string") return s
   if (!s.includes("\\")) return s
@@ -184,7 +192,7 @@ function QuizDialog(props: {
         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 })), multiSelect: isMulti(), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
-        fs.writeFileSync(path.join(pDir, `classify-${props.request.id}.json`), JSON.stringify(pendingClassify), "utf8")
+        writeJsonAtomic(path.join(pDir, `classify-${props.request.id}.json`), pendingClassify)
         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`)
@@ -609,7 +617,7 @@ function QuizBatchDialog(props: {
           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 })), multiSelect: isMulti(), timestamp: Date.now(), sessionID: props.request.sessionID || routeSessionID }
-          fs.writeFileSync(path.join(pDir, `classify-${cid}.json`), JSON.stringify(pendingClassify), "utf8")
+          writeJsonAtomic(path.join(pDir, `classify-${cid}.json`), pendingClassify)
           tlog("QuizBatchDialog classify request", cid, note().trim().slice(0, 50))
           const respPath = path.join(pDir, `classify-response-${cid}.json`)
           let attempts = 0
@@ -778,8 +786,11 @@ export const tui: TuiPlugin = async (api) => {
     if (api.ui.dialog.open) return
     let files: string[] = []
     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}>
+    // Session-distinct: only show pending for current session.
+    // Skip answered-pending (a response file exists, server is consuming): prevents re-popup after answer.
+    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).filter(x => {
+      try { return !fs.existsSync(path.join(pendingDir, `response-${x!.j.id}.json`)) } catch { return true }
+    }) as Array<{f: string, j: any}>
     const pick = matching.find(x => x.j.sessionID === curSid) || matching.find(x => !x.j.sessionID)
     if (!pick) return
     const file = pick.f
@@ -803,7 +814,9 @@ export const tui: TuiPlugin = async (api) => {
     currentBySession.set(curSid, current)
     const done = async (result: any) => {
       const respPath = path.join(pendingDir, `response-${data!.id}.json`)
-      try { fs.writeFileSync(respPath, JSON.stringify({ id: data!.id, type: data!.type, result, sessionID: (data as any).sessionID, at: Date.now() }), "utf8") } catch {}
+      const answerId = data!.id
+      tlog("learn-tui answered", (data as any).type, answerId, JSON.stringify(result).slice(0, 160))
+      writeJsonAtomic(respPath, { id: data!.id, type: data!.type, result, sessionID: (data as any).sessionID, at: Date.now() })
       // Non-blocking wake: inject answer as new user prompt so agent continues (no timeout, no polling waste)
       try {
         const sessionID = (data as any).sessionID
@@ -862,14 +875,26 @@ export const tui: TuiPlugin = async (api) => {
           }
         }
       } catch {}
-      try { fs.unlinkSync(full) } catch {}
+      // Server owns lifecycle: it unlinks the pending file after successful inject.
+      // Do NOT delete pending here — deleting it destroys recovery context if the server hasn't consumed the response yet.
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)
+      // Watchdog: if the response is still unconsumed after 8s, re-touch to retrigger the server watch + log loudly.
+      // Safe: server claims via atomic rename, so a rewrite can never cause double-inject.
+      setTimeout(() => {
+        try {
+          if (fs.existsSync(respPath)) {
+            tlog("learn-tui response NOT consumed, re-touching", answerId)
+            try { writeJsonAtomic(respPath, JSON.parse(fs.readFileSync(respPath, "utf8"))) } catch {}
+          }
+        } catch {}
+      }, 8000)
     }
     const cancel = async () => {
       const respPath = path.join(pendingDir, `response-${data!.id}.json`)
-      try { fs.writeFileSync(respPath, JSON.stringify({ id: data!.id, type: data!.type, cancelled: true, sessionID: (data as any).sessionID, at: Date.now() }), "utf8") } catch {}
+      tlog("learn-tui cancelled", (data as any).type, data!.id)
+      writeJsonAtomic(respPath, { id: data!.id, type: data!.type, cancelled: true, sessionID: (data as any).sessionID, at: Date.now() })
       try {
         const sid = (data as any).sessionID
         if (sid) {
@@ -885,7 +910,7 @@ export const tui: TuiPlugin = async (api) => {
           } catch {}
         }
       } catch {}
-      try { fs.unlinkSync(full) } catch {}
+      // Server owns lifecycle: it unlinks the pending file after consuming the cancelled response.
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)

package/plugins/learn.ts

@@ -244,12 +244,31 @@ function answerCalloutQuiz(details: any): string {
   if (details?.explanation) { body.push(""); for (const line of String(details.explanation).split("\n")) body.push(line) }
   return callout(type, title, body)
 }
+function answerCalloutQuestion(questions: any[], answers: string[][]): string {
+  const qs = Array.isArray(questions) ? questions : []
+  const ans = Array.isArray(answers) ? answers : []
+  if (!qs.length) {
+    const flat = ans.map(a => Array.isArray(a) ? a.join(", ") : String(a ?? "")).filter(Boolean)
+    return callout("example", "Answer", flat.length ? flat : ["(no answer)"])
+  }
+  const body = qs.map((q: any, i: number) => {
+    const header = q?.header || `Q${i + 1}`
+    const sel: string[] = Array.isArray(ans[i]) ? ans[i] as string[] : []
+    return `${header}: ${sel.length ? sel.join(", ") : "(no answer)"}`
+  })
+  return callout("example", "Answer", body)
+}
 function answerCalloutAsk(details: any): string {
   const status = details?.status
   if (status === "cancelled") return callout("warning", "Question — cancelled", ["(user skipped)"])
   if (status === "unavailable") return callout("warning", "Question — unavailable", [details?.message || ""])
   const answers: any[] = details?.answers || []
-  const body: string[] = answers.map((a) => { if (a.type === "other") return `Other: ${a.label}`; if (a.type === "text") return a.label; return `${a.index}. ${a.label}` })
+  // Native opencode shape: string[][] (per-question selected labels)
+  if (answers.length && (answers as any[]).every(a => Array.isArray(a))) {
+    const questions: any[] = details?.questions || []
+    return answerCalloutQuestion(questions, answers as string[][])
+  }
+  const body: string[] = answers.map((a) => { if (a.type === "other") return `Other: ${a.label}`; if (a.type === "text") return a.label; if (typeof a === "string") return a; return `${a.index}. ${a.label}` })
   if (body.length === 0) body.push("(no answer)")
   return callout("example", "Answer", body)
 }
@@ -310,6 +329,23 @@ async function backfillMdLog(client: any, sessionID: string, directory: string):
             }
             continue
           }
+          if (toolName === "question" && Array.isArray((input as any).questions)) {
+            const qs: any[] = (input as any).questions
+            if (st.status === "pending" || st.status === "running") {
+              qs.forEach((q: any, i: number) => {
+                if (!q?.question) return
+                blocks.push(questionCallout(q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question"), q.question, undefined, q.options ?? []))
+              })
+            } else if (st.status === "completed") {
+              qs.forEach((q: any, i: number) => {
+                if (!q?.question) return
+                blocks.push(questionCallout(q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question"), q.question, undefined, q.options ?? []))
+              })
+              const ans = Array.isArray(meta.answers) ? meta.answers : []
+              blocks.push(answerCalloutAsk({ answers: ans, questions: qs, status: "completed" }))
+            }
+            continue
+          }
           if (st.status === "pending" || st.status === "running") {
             if (input.question) {
               const opts = Array.isArray(input.options) ? input.options : []
@@ -446,14 +482,39 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
   if (!sessionID) { slog("watchAndInject no sessionID", id); return }
   const dir = pendingDir(directory)
   const respPath = path.join(dir, `response-${id}.json`)
-  const fire = async () => {
+  const claimPath = path.join(dir, `response-${id}.claim-${process.pid}.json`)
+  const pendingCandidates = [path.join(dir, `quiz-${id}.json`), path.join(dir, `quiz_batch-${id}.json`)]
+  const closeWatcher = () => { const w = activeWatchers.get(id); if (w) { try { w.close() } catch {}; activeWatchers.delete(id) } }
+  const fire = async (attempt = 0): Promise<void> => {
+    // Atomic single-consumer claim: exactly one process proceeds (fixes double-inject across processes)
+    try { fs.renameSync(respPath, claimPath) } catch { closeWatcher(); return } // already claimed/consumed → stand down
     let data: any
-    try { data = JSON.parse(fs.readFileSync(respPath, "utf8")) } catch { return }
-    try { fs.unlinkSync(respPath) } catch {}
-    const w = activeWatchers.get(id); if (w) { try { w.close() } catch {}; activeWatchers.delete(id) }
-    slog("watchAndInject fire", id, JSON.stringify(data).slice(0,400))
-    const effectiveSessionID = (data as any)?.sessionID || sessionID
-    const text = data?.cancelled ? `[cancelled] user dismissed the popup for ${id}` : buildText(data.result)
+    try {
+      data = JSON.parse(fs.readFileSync(claimPath, "utf8"))
+    } catch (e) {
+      if (attempt < 5) {
+        await new Promise(r => setTimeout(r, 120))
+        try { fs.renameSync(claimPath, respPath) } catch {}
+        await new Promise(r => setTimeout(r, 60))
+        return fire(attempt + 1)
+      }
+      slog("watchAndInject UNREADABLE response, parked", id, String(e).slice(0,160))
+      try { fs.renameSync(claimPath, path.join(dir, `response-${id}.poisoned-${Date.now()}.json`)) } catch {}
+      closeWatcher()
+      return
+    }
+    let text: string
+    let effectiveSessionID: string
+    try {
+      slog("watchAndInject fire", id, JSON.stringify(data).slice(0,400))
+      effectiveSessionID = (data as any)?.sessionID || sessionID
+      text = data?.cancelled ? `[cancelled] user dismissed the popup for ${id}` : buildText(data.result)
+    } catch (e) {
+      slog("watchAndInject buildText ERROR, parked", id, String(e).slice(0,200))
+      try { fs.renameSync(claimPath, path.join(dir, `response-${id}.poisoned-${Date.now()}.json`)) } catch {}
+      closeWatcher()
+      return
+    }
     // opencode-loop sdk.js:24 — SDK returns {data,error}, it does NOT throw. Must inspect .error.
     const sdkCall = async (method: any, ...argsList: any[]) => {
       let firstErr: any
@@ -476,23 +537,39 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
     ]
     slog("watchAndInject injecting", id, effectiveSessionID, text.slice(0,300))
     let ok = false
+    let firstErr: any
     // loopd host-adapter.ts:100 — promptAsync wakes the session (fire-and-forget turn)
     if (client?.session?.promptAsync) {
-      try { await sdkCall(client.session.promptAsync.bind(client.session), ...shapes); ok = true } catch {}
+      try { await sdkCall(client.session.promptAsync.bind(client.session), ...shapes); ok = true } catch (e) { firstErr = e }
     }
     if (!ok && client?.session?.prompt) {
-      try { await sdkCall(client.session.prompt.bind(client.session), ...shapes); ok = true } catch {}
+      try { await sdkCall(client.session.prompt.bind(client.session), ...shapes); ok = true } catch (e) { firstErr = firstErr || e }
     }
+    if (!ok) {
+      slog("watchAndInject inject FAILED, preserved", id, effectiveSessionID, String(firstErr).slice(0,200))
+      try { fs.renameSync(claimPath, path.join(dir, `response-${id}.failed-${Date.now()}.json`)) } catch {}
+      try {
+        await client.app.log({ body: { service: "learn", level: "error", message: `inject FAILED for ${effectiveSessionID} (orig ${sessionID})`, extra: { id } } })
+      } catch {}
+      closeWatcher()
+      return
+    }
+    // Success: server owns lifecycle — consume claim + pending (TUI no longer deletes pending)
+    try { fs.unlinkSync(claimPath) } catch {}
+    for (const p of pendingCandidates) try { fs.unlinkSync(p) } catch {}
+    closeWatcher()
+    slog("watchAndInject consumed", id, effectiveSessionID)
     try {
-      await client.app.log({ body: { service: "learn", level: ok ? "info" : "error", message: ok ? `injected into ${effectiveSessionID}` : `inject FAILED for ${effectiveSessionID} (orig ${sessionID})`, extra: { id } } })
+      await client.app.log({ body: { service: "learn", level: "info", message: `injected into ${effectiveSessionID}`, extra: { id } } })
     } catch {}
   }
-  if (fs.existsSync(respPath)) { slog("watchAndInject fast-path", id); void fire(); return }
   try {
-    const w = fs.watch(dir, (_e, filename) => { if (filename === `response-${id}.json` && fs.existsSync(respPath)) void fire() })
+    const w = fs.watch(dir, (_e, filename) => { if (filename === `response-${id}.json`) void fire() })
     w.on("error", () => {})
     activeWatchers.set(id, w)
   } catch {}
+  // Recheck after arming to close the event gap (claim makes double-fire safe)
+  if (fs.existsSync(respPath)) { slog("watchAndInject fast-path", id); void fire(); return }
 }
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -744,6 +821,21 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
   try {
     const dir = pendingDir(directory)
     if (fs.existsSync(dir)) {
+      // 1) Requeue stale claims from consumers that died mid-flight (>30s old, no live response)
+      for (const f of fs.readdirSync(dir).filter(x => x.includes(".claim-") && x.endsWith(".json"))) {
+        try {
+          const m = f.match(/^response-(.+)\.claim-.*\.json$/)
+          if (!m) continue
+          const rid = m[1]!
+          const target = path.join(dir, `response-${rid}.json`)
+          const age = Date.now() - fs.statSync(path.join(dir, f)).mtimeMs
+          if (age > 30000 && !fs.existsSync(target)) {
+            fs.renameSync(path.join(dir, f), target)
+            slog("watchAndInject requeued stale claim", rid)
+          }
+        } catch {}
+      }
+      // 2) Re-arm pending quizzes (fast-path inside watchAndInject consumes any waiting response)
       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"))
@@ -793,6 +885,19 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
           }
         } catch {}
       }
+      // 3) Park legacy orphans: response with no pending context (pre-fix leftovers) — can't rebuild inject text, park loudly instead of rotting silently
+      for (const f of fs.readdirSync(dir).filter(x => x.startsWith("response-") && x.endsWith(".json") && !x.includes(".claim-") && !x.includes(".poisoned") && !x.includes(".failed") && !x.includes(".orphaned"))) {
+        try {
+          const m = f.match(/^response-(.+)\.json$/)
+          if (!m) continue
+          const rid = m[1]!
+          const hasPending = fs.existsSync(path.join(dir, `quiz-${rid}.json`)) || fs.existsSync(path.join(dir, `quiz_batch-${rid}.json`))
+          if (!hasPending) {
+            fs.renameSync(path.join(dir, f), path.join(dir, `response-${rid}.orphaned-${Date.now()}.json`))
+            slog("watchAndInject orphaned response parked (no pending context)", rid)
+          }
+        } catch {}
+      }
     }
   } catch {}
 
@@ -849,24 +954,28 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
         await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, assistantBlock(stripSkillBlocks(text))))
       } catch {}
     },
-    "tool.execute.before": async (input) => {
+    "tool.execute.before": async (input, output) => {
       try {
         const ses = extractHookSessionID((input as any)?.sessionID)
         const mdFile = getMdFile(ses)
         if (!mdFile || !ses) return
         const toolName = (input as any).tool
-        const args = (input as any).args ?? {}
-        // Built-in `question` tool is used as fallback when TUI not alive; mirror it.
-        // `ask_user_question` is already mirrored inside its own execute (with correct TUI handling), so skip to avoid duplicate.
+        // NOTE: per Hooks type, before-hook args live in output.args (input only has tool/sessionID/callID).
+        const args = (output as any)?.args ?? (input as any).args ?? {}
+        // Native `question` tool shape: {questions: [{question, header, options, multiple}]}
         if (toolName === "question") {
-          const q = args.question || args.header || ""
-          const ctx2 = args.details?.trim() || undefined
-          const opts = Array.isArray(args.options) ? args.options : []
           const callID = (input as any).callID
           const qkey = callID ? mdKey(ses, `q:${callID}`) : undefined
           if (qkey && loggedToolCallIds.has(qkey)) return
           if (qkey) loggedToolCallIds.add(qkey)
-          if (q) await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, questionCallout("Question", q, ctx2, opts)))
+          const qs: any[] = Array.isArray(args.questions) ? args.questions
+            : (args.question ? [{ question: args.question, header: args.header, options: args.options ?? [] }] : [])
+          for (let i = 0; i < qs.length; i++) {
+            const q = qs[i]
+            if (!q?.question) continue
+            const label = q.header || (qs.length > 1 ? `Question ${i + 1}/${qs.length}` : "Question")
+            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, questionCallout(label, q.question, undefined, q.options ?? [])))
+          }
         }
       } catch {}
     },
@@ -880,10 +989,20 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
         const akey = callID ? mdKey(ses, `answer:${callID}`) : undefined
         if (akey && loggedToolCallIds.has(akey)) return
         if (toolName === "question") {
-          const meta: any = (output as any).metadata ?? {}
-          let answers: any[] = meta.answers ?? []
-          if (!answers.length && (output as any).output) answers = []
-          const details: any = { answers, status: "completed" }
+          const meta: any = (output as any)?.metadata ?? {}
+          const inArgs: any = (input as any)?.args ?? {}
+          const qs: any[] = Array.isArray(inArgs.questions) ? inArgs.questions : []
+          let answers: any = meta.answers
+          if (!Array.isArray(answers) || !answers.length) {
+            const outText = typeof (output as any)?.output === "string" ? ((output as any).output as string).trim() : ""
+            if (outText) {
+              await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, callout("example", "Answer", [outText.slice(0, 500)])))
+              if (akey) loggedToolCallIds.add(akey)
+              return
+            }
+            answers = []
+          }
+          const details: any = { answers, questions: qs, status: "completed" }
           await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, answerCalloutAsk(details)))
           if (akey) loggedToolCallIds.add(akey)
         }