@bojackduy/opencode-learn 1.2.4 → 1.2.5

package/dist/server.js

@@ -649,9 +649,8 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
     } catch {}
   };
   try {
-    const w = fs.watch(dir, (_e, filename) => {
-      if (filename === `response-${id}.json`)
-        fire();
+    const w = fs.watch(dir, () => {
+      fire();
     });
     w.on("error", () => {});
     activeWatchers.set(id, w);
@@ -901,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 {}
   }

package/dist/tui.js

@@ -2797,6 +2797,9 @@ var tui = async (api) => {
           }
         }
       } catch {}
+      try {
+        fs.unlinkSync(full);
+      } catch {}
       api.ui.dialog.clear();
       currentBySession.delete(curSid);
       setTimeout(processPending, 150);
@@ -2856,6 +2859,9 @@ 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.4",
+  "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

@@ -875,12 +875,13 @@ export const tui: TuiPlugin = async (api) => {
           }
         }
       } 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.
+      // 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 after 8s, re-touch to retrigger the server watch + log loudly.
+      // 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 {
@@ -910,7 +911,7 @@ export const tui: TuiPlugin = async (api) => {
           } catch {}
         }
       } catch {}
-      // Server owns lifecycle: it unlinks the pending file after consuming the cancelled response.
+      try { fs.unlinkSync(full) } catch {}
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)

package/plugins/learn.ts

@@ -554,7 +554,7 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
       closeWatcher()
       return
     }
-    // Success: server owns lifecycle — consume claim + pending (TUI no longer deletes pending)
+    // 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()
@@ -564,7 +564,10 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
     } catch {}
   }
   try {
-    const w = fs.watch(dir, (_e, filename) => { if (filename === `response-${id}.json`) 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 {}
@@ -803,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 {}