@bojackduy/opencode-learn 1.2.3 → 1.2.5

package/dist/server.js

@@ -531,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) {
@@ -576,35 +607,59 @@ 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))
-        fire();
+    const w = fs.watch(dir, () => {
+      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");
@@ -845,16 +900,16 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
         slog("classify response written", data.id, inferred.join(","));
       } catch {}
     };
+    const sweep = () => {
+      try {
+        for (const f of fs.readdirSync(dir).filter((f) => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
+          processClassify(f);
+        }
+      } catch {}
+    };
+    sweep();
     try {
-      for (const f of fs.readdirSync(dir).filter((f) => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
-        processClassify(f);
-      }
-    } catch {}
-    try {
-      const w = fs.watch(dir, (_e, filename) => {
-        if (filename)
-          processClassify(filename);
-      });
+      const w = fs.watch(dir, () => sweep());
       w.on("error", () => {});
     } catch {}
   }
@@ -862,6 +917,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"));
@@ -918,6 +987,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 {

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 = "";
@@ -2786,18 +2803,27 @@ var tui = async (api) => {
       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) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "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,27 @@ export const tui: TuiPlugin = async (api) => {
           }
         }
       } catch {}
+      // TUI owns dialog lifecycle — always delete pending + close immediately so Enter never appears to "do nothing",
+      // regardless of whether another (possibly stale/old-code) opencode process is also running.
       try { fs.unlinkSync(full) } catch {}
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)
+      // Watchdog: if the response is still unconsumed (server didn't fire) after 8s, re-touch to retrigger the 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) {

package/plugins/learn.ts

@@ -482,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
@@ -512,23 +537,42 @@ 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: consume claim + defensively try pending too (TUI is the primary owner of pending deletion)
+    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() })
+    // Fire on ANY directory event, not just exact filename match — atomic tmp+rename writes can report
+    // a different filename (or no filename) on some fs.watch backends (notably macOS FSEvents). The claim
+    // rename inside fire() makes this safe to call spuriously: if respPath doesn't exist yet, it just no-ops.
+    const w = fs.watch(dir, () => { 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 }
 }
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -762,14 +806,20 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       const out = { id: data.id, inferredIndices: inferred, inferredValues, semanticCorrect, reason, isIDK, 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 {}
     }
+    const sweep = () => {
+      try {
+        for (const f of fs.readdirSync(dir).filter(f => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
+          void processClassify(f)
+        }
+      } catch {}
+    }
     // Initial sweep
+    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) })
+      // Re-scan on ANY directory event rather than trusting the reported filename — atomic tmp+rename
+      // writes (used by the TUI) can report a different filename (or none) on some fs.watch backends
+      // (notably macOS FSEvents), which would otherwise silently drop classify requests.
+      const w = fs.watch(dir, () => sweep())
       w.on("error", () => {})
       // Keep watcher alive; store to avoid GC? No need.
     } catch {}
@@ -780,6 +830,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"))
@@ -829,6 +894,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 {}