@bojackduy/opencode-learn 1.2.0 → 1.2.2

package/dist/server.js

@@ -1,6 +1,4 @@
 // @bun
-var __require = import.meta.require;
-
 // plugins/learn.ts
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
@@ -159,30 +157,86 @@ function decodeQuizText(s) {
   out = out.replace(/\\\\/g, "\\");
   return out;
 }
-var mdLogFile = null;
-var mdLogWriteLock = Promise.resolve();
-function withMdLock(fn) {
-  const prev = mdLogWriteLock;
+var mdLinks = new Map;
+var mdFileLocks = new Map;
+function withMdFileLock(file, fn) {
+  const prev = mdFileLocks.get(file) ?? Promise.resolve();
   let release;
-  mdLogWriteLock = new Promise((r) => {
+  const next = new Promise((r) => {
     release = r;
   });
+  mdFileLocks.set(file, next);
   return prev.then(fn).finally(() => release());
 }
-function appendToMdLog(text) {
-  if (!mdLogFile)
+function getMdFile(sessionID) {
+  if (!sessionID)
+    return;
+  return mdLinks.get(sessionID)?.file;
+}
+function appendToMdLogForSession(sessionID, text) {
+  const file = getMdFile(sessionID);
+  if (!file || !sessionID)
     return;
   try {
     let current = "";
-    if (fs.existsSync(mdLogFile))
-      current = fs.readFileSync(mdLogFile, "utf-8");
+    if (fs.existsSync(file))
+      current = fs.readFileSync(file, "utf-8");
     const prefix = current.trim().length > 0 ? `
 
 ` : "";
-    fs.writeFileSync(mdLogFile, current + prefix + text + `
+    fs.writeFileSync(file, current + prefix + text + `
 `, "utf-8");
   } catch {}
 }
+function loadMdLinks(markerPath, directory) {
+  try {
+    if (!fs.existsSync(markerPath))
+      return 0;
+    const data = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+    if (data && typeof data.file === "string" && !data.links) {
+      try {
+        fs.writeFileSync(markerPath + ".bak", JSON.stringify(data), "utf-8");
+      } catch {}
+      try {
+        fs.writeFileSync(markerPath, JSON.stringify({ version: 1, links: {} }), "utf-8");
+      } catch {}
+      try {
+        slog("md-log legacy marker backed up, starting empty 1-1-1", markerPath);
+      } catch {}
+      return 0;
+    }
+    const links = data?.links ?? {};
+    let n = 0;
+    for (const [ses, v] of Object.entries(links)) {
+      const f = v?.file ?? (typeof v === "string" ? v : undefined);
+      if (typeof ses === "string" && typeof f === "string" && fs.existsSync(f)) {
+        mdLinks.set(ses, { file: f, directory: v?.directory || directory, linkedAt: v?.linkedAt || Date.now() });
+        n++;
+      }
+    }
+    return n;
+  } catch {
+    return 0;
+  }
+}
+function saveMdLinksForDirectory(markerPath, directory) {
+  try {
+    const out = {};
+    for (const [ses, meta] of mdLinks) {
+      if (meta.directory === directory)
+        out[ses] = meta;
+    }
+    fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+    fs.writeFileSync(markerPath, JSON.stringify({ version: 1, links: out }), "utf-8");
+  } catch {}
+}
+function extractHookSessionID(...candidates) {
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0)
+      return c;
+  }
+  return;
+}
 function callout(type, title, bodyLines) {
   const lines = [`> [!${type}] ${title}`];
   for (const line of bodyLines)
@@ -282,7 +336,8 @@ function answerCalloutAsk(details) {
   return callout("example", "Answer", body);
 }
 async function backfillMdLog(client, sessionID, directory) {
-  if (!mdLogFile || !sessionID)
+  const mdFile = getMdFile(sessionID);
+  if (!mdFile || !sessionID)
     return 0;
   try {
     const res = await client.session.messages({ path: { id: sessionID }, query: { directory } });
@@ -372,13 +427,14 @@ async function backfillMdLog(client, sessionID, directory) {
       }
     }
     if (blocks.length) {
+      const mdFile2 = getMdFile(sessionID) || mdFile;
       let current = "";
       try {
-        if (fs.existsSync(mdLogFile))
-          current = fs.readFileSync(mdLogFile, "utf-8");
+        if (fs.existsSync(mdFile2))
+          current = fs.readFileSync(mdFile2, "utf-8");
       } catch {}
       if (current.trim().length === 0) {
-        fs.writeFileSync(mdLogFile, blocks.join(`
+        fs.writeFileSync(mdFile2, blocks.join(`
 
 `) + `
 `, "utf-8");
@@ -386,7 +442,7 @@ async function backfillMdLog(client, sessionID, directory) {
         const prefix = current.trim().length > 0 ? `
 
 ` : "";
-        fs.writeFileSync(mdLogFile, current + prefix + blocks.join(`
+        fs.writeFileSync(mdFile2, current + prefix + blocks.join(`
 
 `) + `
 `, "utf-8");
@@ -514,17 +570,16 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
 var server = async ({ client, directory }) => {
   const markerPath = path.join(directory, ".opencode", "learn-md-log.json");
   try {
-    if (fs.existsSync(markerPath)) {
-      const data = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
-      if (data?.file && fs.existsSync(data.file))
-        mdLogFile = data.file;
-    }
+    const n = loadMdLinks(markerPath, directory);
+    if (n)
+      slog("md-log links restored", n, markerPath);
   } catch {}
   let mermaidSession = null;
   let svgSession = null;
   const loggedTextPartIds = new Set;
   const loggedToolCallIds = new Set;
   const messageIdToRole = new Map;
+  const mdKey = (ses, id) => `${ses || "?"}:${id}`;
   function heuristicClassify(note, options, multiSelect) {
     const n = note.toLowerCase();
     const scored = [];
@@ -554,7 +609,7 @@ var server = async ({ client, directory }) => {
     }
     return uniq;
   }
-  async function llmClassify(client2, directory2, note, options, question, parentSessionID, multiSelect) {
+  async function llmClassify(client, directory, note, options, question, parentSessionID, multiSelect) {
     const modeHint = multiSelect ? "This is a MULTI-SELECT question (0..N options may be correct). You may return 0..N inferred indices." : "This is a SINGLE-SELECT question (exactly 0 or 1 inferred). You MUST return at most ONE inferred index. Never return multiple. If note is ambiguous or mentions several options, pick the SINGLE best match. Return [] if vague.";
     const idkHint = `Also detect IDK intent: if note says "I don't know / idk / too hard / too difficult / need easier / want easier / skip / give me easier/harder" or expresses wanting difficulty adjustment, set "isIDK": true (and keep inferred as [] or best guess). Otherwise isIDK false. The main teacher will use this to adapt difficulty.`;
     const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options. ${modeHint} ${idkHint}
@@ -574,7 +629,7 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       const body = { title };
       if (parentSessionID)
         body.parentID = parentSessionID;
-      const created = await client2.session.create({ body, query: { directory: directory2 } });
+      const created = await client.session.create({ body, query: { directory } });
       const sid = created?.data?.id || created?.id || created?.data?.sessionID;
       if (!sid)
         throw new Error("no sid");
@@ -583,24 +638,24 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       if (parentSessionID && createdSession?.parentID !== parentSessionID) {
         throw new Error(`classifier parent mismatch: expected ${parentSessionID}, got ${createdSession?.parentID || "none"}`);
       }
-      await client2.session.prompt({ path: { id: sid }, body: { parts: [{ type: "text", text: prompt }], agent: "classify" } });
+      await client.session.prompt({ path: { id: sid }, body: { parts: [{ type: "text", text: prompt }], agent: "classify" } });
       for (let i = 0;i < 24; i++) {
         await new Promise((r) => setTimeout(r, 500));
         try {
-          const msgs = await client2.session.messages({ path: { id: sid } });
+          const msgs = await client.session.messages({ path: { id: sid } });
           const data = msgs?.data || msgs;
           const arr = Array.isArray(data) ? data : [];
           for (let j = arr.length - 1;j >= 0; j--) {
             const entry = arr[j];
             if (entry?.info?.role === "assistant") {
               const text = (entry.parts || []).filter((p) => p.type === "text").map((p) => p.text).join(" ") || "";
-              const enforceSingle = (arr2) => {
-                if (!multiSelect && arr2.length > 1) {
-                  const trimmed = [arr2[0]];
-                  slog("llmClassify enforce single", arr2.join(","), "->", trimmed.join(","), multiSelect ? "multi" : "single");
+              const enforceSingle = (arr) => {
+                if (!multiSelect && arr.length > 1) {
+                  const trimmed = [arr[0]];
+                  slog("llmClassify enforce single", arr.join(","), "->", trimmed.join(","), multiSelect ? "multi" : "single");
                   return trimmed;
                 }
-                return arr2;
+                return arr;
               };
               const noteIsIDK = (() => {
                 const n = note.toLowerCase();
@@ -657,8 +712,8 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
     }
     return { inferred: [] };
   }
-  function startClassifyWatcher(client2, directory2) {
-    const dir = pendingDir(directory2);
+  function startClassifyWatcher(client, directory) {
+    const dir = pendingDir(directory);
     try {
       fs.mkdirSync(dir, { recursive: true });
     } catch {}
@@ -687,7 +742,7 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       let reason;
       let isIDK;
       const multi = !!data.multiSelect;
-      const llmRes = await llmClassify(client2, directory2, data.note, data.options, data.question, data.sessionID, multi);
+      const llmRes = await llmClassify(client, directory, data.note, data.options, data.question, data.sessionID, multi);
       isIDK = llmRes.isIDK;
       if (!isIDK) {
         const n = data.note.toLowerCase();
@@ -752,7 +807,7 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       } catch {}
     };
     try {
-      for (const f of fs.readdirSync(dir).filter((f2) => f2.startsWith("classify-") && !f2.startsWith("classify-response-"))) {
+      for (const f of fs.readdirSync(dir).filter((f) => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
         processClassify(f);
       }
     } catch {}
@@ -782,9 +837,11 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
                 const ok = !dk && si.length === (j.correctIndices || []).length && si.every((i) => cs.has(i));
                 const note = r?.note ? `
 Note: ${r.note}` : "";
-                if (mdLogFile) {
+                if (getMdFile(j.sessionID)) {
                   const details = { status: "completed", answers: r?.answers || [], correct: ok, correctIndices: j.correctIndices || [], explanation: j.explanation, dontKnow: dk, note: r?.note };
-                  withMdLock(() => appendToMdLog(answerCalloutQuiz(details)));
+                  const sesJ = j.sessionID;
+                  const fJ = getMdFile(sesJ);
+                  withMdFileLock(fJ, () => appendToMdLogForSession(sesJ, answerCalloutQuiz(details)));
                 }
                 return dk ? `[quiz answered] "${j.question}" -> I don't know.
 Correct: ${cstr}
@@ -793,12 +850,14 @@ Correct: ${cstr}
 Explanation: ${j.explanation}${note}`;
               } else if (j.type === "quiz_batch") {
                 const results = r?.results || [];
-                if (mdLogFile) {
+                if (getMdFile(j.sessionID)) {
                   for (let i = 0;i < (j.quizzes || []).length; i++) {
                     const qq = j.quizzes[i];
                     const x = results[i] || {};
                     const details = { status: "completed", answers: x.answers || [], correct: !!x.correct, correctIndices: qq.correctIndices || [], explanation: qq.explanation || "", dontKnow: !!x.dontKnow, note: x.note };
-                    withMdLock(() => appendToMdLog(answerCalloutQuiz(details)));
+                    const sesJ = j.sessionID;
+                    const fJ = getMdFile(sesJ);
+                    withMdFileLock(fJ, () => appendToMdLogForSession(sesJ, answerCalloutQuiz(details)));
                   }
                 }
                 const lines = (j.quizzes || []).map((qq, i) => {
@@ -836,10 +895,12 @@ Explanation: ${j.explanation}${note}`;
         output.agent = agents;
       await client.app.log({ body: { service: "learn", level: "info", message: "learn plugin initialized", extra: { directory } } });
     },
-    "chat.message": async (_input, output) => {
-      if (!mdLogFile)
-        return;
+    "chat.message": async (input, output) => {
       try {
+        const ses = extractHookSessionID(input?.sessionID, output?.message?.sessionID);
+        const mdFile = getMdFile(ses);
+        if (!mdFile || !ses)
+          return;
         const msg = output.message;
         const parts = output.parts ?? [];
         let text = "";
@@ -857,31 +918,37 @@ Explanation: ${j.explanation}${note}`;
         if (/^\[(quiz|quiz_batch|question) (answered|cancelled)\]/i.test(text) || text.startsWith("[quiz answered]") || text.startsWith("[quiz_batch answered]") || text.startsWith("[question answered]"))
           return;
         const mid = msg?.id ? `msg:${msg.id}` : `chat:${Date.now()}`;
-        if (loggedTextPartIds.has(mid))
+        const mkey = mdKey(ses, mid);
+        if (loggedTextPartIds.has(mkey))
           return;
-        loggedTextPartIds.add(mid);
-        await withMdLock(() => appendToMdLog(userBlock(text)));
+        loggedTextPartIds.add(mkey);
+        await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, userBlock(text)));
       } catch {}
     },
     "experimental.text.complete": async (input, output) => {
-      if (!mdLogFile)
-        return;
       try {
+        const ses = extractHookSessionID(input?.sessionID);
+        const mdFile = getMdFile(ses);
+        if (!mdFile || !ses)
+          return;
         const text = output.text?.trim();
         if (!text)
           return;
         const partID = input.partID;
-        if (partID && loggedTextPartIds.has(partID))
+        const pkey = partID ? mdKey(ses, partID) : undefined;
+        if (pkey && loggedTextPartIds.has(pkey))
           return;
-        if (partID)
-          loggedTextPartIds.add(partID);
-        await withMdLock(() => appendToMdLog(assistantBlock(stripSkillBlocks(text))));
+        if (pkey)
+          loggedTextPartIds.add(pkey);
+        await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, assistantBlock(stripSkillBlocks(text))));
       } catch {}
     },
     "tool.execute.before": async (input) => {
-      if (!mdLogFile)
-        return;
       try {
+        const ses = extractHookSessionID(input?.sessionID);
+        const mdFile = getMdFile(ses);
+        if (!mdFile || !ses)
+          return;
         const toolName = input.tool;
         const args = input.args ?? {};
         if (toolName === "question") {
@@ -889,22 +956,26 @@ Explanation: ${j.explanation}${note}`;
           const ctx2 = args.details?.trim() || undefined;
           const opts = Array.isArray(args.options) ? args.options : [];
           const callID = input.callID;
-          if (callID && loggedToolCallIds.has(`q:${callID}`))
+          const qkey = callID ? mdKey(ses, `q:${callID}`) : undefined;
+          if (qkey && loggedToolCallIds.has(qkey))
             return;
-          if (callID)
-            loggedToolCallIds.add(`q:${callID}`);
+          if (qkey)
+            loggedToolCallIds.add(qkey);
           if (q)
-            await withMdLock(() => appendToMdLog(questionCallout("Question", q, ctx2, opts)));
+            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, questionCallout("Question", q, ctx2, opts)));
         }
       } catch {}
     },
     "tool.execute.after": async (input, output) => {
-      if (!mdLogFile)
-        return;
       try {
+        const ses = extractHookSessionID(input?.sessionID);
+        const mdFile = getMdFile(ses);
+        if (!mdFile || !ses)
+          return;
         const toolName = input.tool;
         const callID = input.callID;
-        if (callID && loggedToolCallIds.has(`answer:${callID}`))
+        const akey = callID ? mdKey(ses, `answer:${callID}`) : undefined;
+        if (akey && loggedToolCallIds.has(akey))
           return;
         if (toolName === "question") {
           const meta = output.metadata ?? {};
@@ -912,15 +983,13 @@ Explanation: ${j.explanation}${note}`;
           if (!answers.length && output.output)
             answers = [];
           const details = { answers, status: "completed" };
-          await withMdLock(() => appendToMdLog(answerCalloutAsk(details)));
-          if (callID)
-            loggedToolCallIds.add(`answer:${callID}`);
+          await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, answerCalloutAsk(details)));
+          if (akey)
+            loggedToolCallIds.add(akey);
         }
       } catch {}
     },
     event: async ({ event }) => {
-      if (!mdLogFile)
-        return;
       const t = event.type;
       const props = event.properties ?? {};
       try {
@@ -928,18 +997,24 @@ Explanation: ${j.explanation}${note}`;
           const info = props.info;
           if (info?.id && info?.role)
             messageIdToRole.set(info.id, info.role);
+          return;
         } else if (t === "message.part.updated") {
           const part = props.part;
           const delta = props.delta;
           if (!part || !part.id)
             return;
+          const ses = extractHookSessionID(part.sessionID, props?.sessionID, props.info?.sessionID);
+          const mdFile = getMdFile(ses);
+          if (!mdFile || !ses)
+            return;
           if (part.type === "text") {
             if (part.synthetic || part.ignored)
               return;
             const isFinal = !!(part.time?.end !== undefined) || delta === undefined;
             if (!isFinal)
               return;
-            if (loggedTextPartIds.has(part.id))
+            const pkey = mdKey(ses, part.id);
+            if (loggedTextPartIds.has(pkey))
               return;
             const text = (part.text || "").trim();
             if (!text)
@@ -947,8 +1022,8 @@ Explanation: ${j.explanation}${note}`;
             const role = messageIdToRole.get(part.messageID);
             if (role === "user")
               return;
-            loggedTextPartIds.add(part.id);
-            await withMdLock(() => appendToMdLog(assistantBlock(stripSkillBlocks(text))));
+            loggedTextPartIds.add(pkey);
+            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, assistantBlock(stripSkillBlocks(text))));
           }
         }
       } catch {}
@@ -1018,6 +1093,7 @@ Explanation: ${j.explanation}${note}`;
           try {
             await ctx.metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { pendingId: id } });
           } catch {}
+          const quizSes = ctx.sessionID;
           watchAndInject(client, directory, id, ctx.sessionID, (r) => {
             const dk = !!r?.dontKnow;
             const sel = (r?.answers || []).map((a) => `${a.index}. ${a.label}`).join(", ") || "(none)";
@@ -1026,7 +1102,8 @@ Explanation: ${j.explanation}${note}`;
             const ok = !dk && si.length === correctIndices.length && si.every((i) => cs.has(i));
             const note = r?.note ? `
 Note: ${r.note}` : "";
-            if (mdLogFile) {
+            const qf = quizSes ? getMdFile(quizSes) : undefined;
+            if (qf && quizSes) {
               const details = {
                 status: "completed",
                 answers: r?.answers || [],
@@ -1036,7 +1113,7 @@ Note: ${r.note}` : "";
                 dontKnow: dk,
                 note: r?.note
               };
-              withMdLock(() => appendToMdLog(answerCalloutQuiz(details)));
+              withMdFileLock(qf, () => appendToMdLogForSession(quizSes, answerCalloutQuiz(details)));
             }
             return dk ? `[quiz answered] "${qFixed}" -> I don't know (genuine gap).
 Correct: ${correctStr}
@@ -1044,10 +1121,13 @@ Explanation: ${eFixed}${note}` : `[quiz answered] "${qFixed}" -> ${sel} = ${ok ?
 Correct: ${correctStr}
 Explanation: ${eFixed}${note}`;
           });
-          if (mdLogFile) {
-            try {
-              await withMdLock(() => appendToMdLog(questionCallout("Quiz", qFixed, dFixed?.trim() || undefined, options.map((o) => ({ label: o.label })))));
-            } catch {}
+          {
+            const qf = quizSes ? getMdFile(quizSes) : undefined;
+            if (qf && quizSes) {
+              try {
+                await withMdFileLock(qf, () => appendToMdLogForSession(quizSes, questionCallout("Quiz", qFixed, dFixed?.trim() || undefined, options.map((o) => ({ label: o.label })))));
+              } catch {}
+            }
           }
           if (tuiAlive) {
             return `[quiz displayed in TUI \u2014 waiting for your answer in the popup. I'll continue once you respond.]`;
@@ -1057,21 +1137,21 @@ Explanation: ${eFixed}${note}`;
           if (isTTY && !insideOpencode) {
             const readline = await import("readline");
             const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            const abortPromise = new Promise((resolve2) => ctx.abort.addEventListener("abort", () => {
+            const abortPromise = new Promise((resolve) => ctx.abort.addEventListener("abort", () => {
               try {
                 rl.close();
               } catch {}
-              resolve2(null);
+              resolve(null);
             }, { once: true }));
             const promptText = `
 [quiz] ${args.question}
 ${args.details ? args.details + `
 ` : ""}${display}
 ${args.multiSelect ? "Select all correct (comma-separated numbers, e.g. 1,3) or 0 for 'I don't know': " : "Select one number or 0 for 'I don't know': "}`;
-            const answerPromise = new Promise((resolve2) => {
+            const answerPromise = new Promise((resolve) => {
               rl.question(promptText, (ans) => {
                 rl.close();
-                resolve2(ans);
+                resolve(ans);
               });
             });
             const raw = await Promise.race([answerPromise, abortPromise]);
@@ -1082,8 +1162,11 @@ ${args.multiSelect ? "Select all correct (comma-separated numbers, e.g. 1,3) or
               const msg = `User selected "I don't know" \u2014 genuine gap, not a guess.
 Correct: ${correctStr}
 Explanation: ${eFixed}`;
-              if (mdLogFile)
-                await withMdLock(() => appendToMdLog(callout("question", "Quiz \u2014 I don't know", [qFixed, trimmed, `Correct: ${correctStr}`, eFixed])));
+              {
+                const qf = quizSes ? getMdFile(quizSes) : undefined;
+                if (qf && quizSes)
+                  await withMdFileLock(qf, () => appendToMdLogForSession(quizSes, callout("question", "Quiz \u2014 I don't know", [qFixed, trimmed, `Correct: ${correctStr}`, eFixed])));
+              }
               return msg;
             }
             const nums = trimmed.split(/[,\s]+/).map((s) => parseInt(s, 10)).filter((n) => !isNaN(n) && n >= 1 && n <= options.length);
@@ -1097,8 +1180,11 @@ Selected: ${selectedStr}
 Correct: ${correctStr}
 Explanation: ${eFixed}`;
             ctx.metadata?.({ title: correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", metadata: { correct, correctIndices, explanation: eFixed } });
-            if (mdLogFile)
-              await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", [`Q: ${qFixed}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, eFixed])));
+            {
+              const qf = quizSes ? getMdFile(quizSes) : undefined;
+              if (qf && quizSes)
+                await withMdFileLock(qf, () => appendToMdLogForSession(quizSes, callout(correct ? "success" : "failure", correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", [`Q: ${qFixed}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, eFixed])));
+            }
             return result;
           }
           const instruction = [
@@ -1184,36 +1270,42 @@ Explanation: ${eFixed}`;
           try {
             await ctx.metadata?.({ title: `Quiz batch ${normalized.length}`, metadata: { pendingId: id } });
           } catch {}
-          if (mdLogFile) {
-            for (let i = 0;i < normalized.length; i++) {
-              const q = normalized[i];
-              const label = `Quiz ${i + 1}/${normalized.length}`;
-              try {
-                await withMdLock(() => appendToMdLog(questionCallout(label, q.question, q.details?.trim() || undefined, q.options.map((o) => ({ label: o.label })))));
-              } catch {}
-            }
-          }
-          watchAndInject(client, directory, id, ctx.sessionID, (r) => {
-            const results = r?.results || [];
-            if (mdLogFile) {
+          const batchSes = ctx.sessionID;
+          {
+            const bf = batchSes ? getMdFile(batchSes) : undefined;
+            if (bf && batchSes) {
               for (let i = 0;i < normalized.length; i++) {
                 const q = normalized[i];
-                const x = results[i] || {};
-                const details = {
-                  status: "completed",
-                  answers: x.answers || [],
-                  correct: !!x.correct,
-                  correctIndices: q.correctIndices || [],
-                  explanation: q.explanation || "",
-                  dontKnow: !!x.dontKnow,
-                  note: x.note
-                };
                 const label = `Quiz ${i + 1}/${normalized.length}`;
                 try {
-                  withMdLock(() => appendToMdLog(answerCalloutQuiz(details)));
+                  await withMdFileLock(bf, () => appendToMdLogForSession(batchSes, questionCallout(label, q.question, q.details?.trim() || undefined, q.options.map((o) => ({ label: o.label })))));
                 } catch {}
               }
             }
+          }
+          watchAndInject(client, directory, id, ctx.sessionID, (r) => {
+            const results = r?.results || [];
+            {
+              const bf = batchSes ? getMdFile(batchSes) : undefined;
+              if (bf && batchSes) {
+                for (let i = 0;i < normalized.length; i++) {
+                  const q = normalized[i];
+                  const x = results[i] || {};
+                  const details = {
+                    status: "completed",
+                    answers: x.answers || [],
+                    correct: !!x.correct,
+                    correctIndices: q.correctIndices || [],
+                    explanation: q.explanation || "",
+                    dontKnow: !!x.dontKnow,
+                    note: x.note
+                  };
+                  try {
+                    withMdFileLock(bf, () => appendToMdLogForSession(batchSes, answerCalloutQuiz(details)));
+                  } catch {}
+                }
+              }
+            }
             const lines = results.map((x, i) => {
               const q = normalized[i];
               const cs = (q.correctIndices || []).map((idx) => `${idx}. ${q.options[idx - 1]?.label}`).join(", ");
@@ -1233,47 +1325,64 @@ Explanation: ${eFixed}`;
         }
       }),
       md_log: tool({
-        description: "Mirror the session to a markdown file for comfortable reading in Obsidian. The file mirrors user prompts, assistant text, and quiz/question Q&A. Use an existing file; it will be backfilled with history. Use `md_unlog` to stop.",
+        description: "Mirror THIS session to a markdown file for comfortable reading in Obsidian. The link is bound 1-1-1 to this sessionID: resuming the same session auto-restores, a different session stays silent until it links its own file. Use `md_unlog` to stop.",
         args: {
           filepath: tool.schema.string().describe("Existing markdown file to link (relative to worktree or absolute). Must exist.")
         },
         async execute(args, ctx) {
+          const sessionID = ctx.sessionID;
+          if (!sessionID)
+            return `md_log error: no sessionID in context \u2014 cannot establish 1-1-1 link`;
           const resolved = path.isAbsolute(args.filepath) ? args.filepath : path.resolve(ctx.directory, args.filepath);
           if (!fs.existsSync(resolved))
             return `File does not exist: ${resolved}`;
           if (!fs.statSync(resolved).isFile())
             return `Not a file: ${resolved}`;
-          mdLogFile = resolved;
-          try {
-            fs.mkdirSync(path.dirname(markerPath), { recursive: true });
-            fs.writeFileSync(markerPath, JSON.stringify({ file: resolved }), "utf-8");
-          } catch {}
-          let backfilled = 0;
-          const sessionID = ctx.sessionID;
-          if (sessionID) {
-            try {
-              backfilled = await backfillMdLog(client, sessionID, directory);
-            } catch (e) {
-              slog("backfill error", String(e));
+          for (const [ses, meta] of mdLinks) {
+            if (meta.file === resolved && ses !== sessionID) {
+              return `File already linked to session ${ses.slice(0, 8)} \u2014 1-1-1 violation. Copy to a new file or md_unlog that session first.`;
             }
           }
-          await client.app.log({ body: { service: "learn", level: "info", message: `md-log linked: ${resolved}`, extra: { file: resolved, backfilled } } });
-          return `Linked: ${resolved} \u2014 ${backfilled ? `${backfilled} entries backfilled \u2014 ` : ""}future messages will be mirrored. View it rendered in Obsidian for LaTeX/math.`;
+          mdLinks.set(sessionID, { file: resolved, directory, linkedAt: Date.now() });
+          saveMdLinksForDirectory(markerPath, directory);
+          let backfilled = 0;
+          try {
+            backfilled = await backfillMdLog(client, sessionID, directory);
+          } catch (e) {
+            slog("backfill error", String(e));
+          }
+          await client.app.log({ body: { service: "learn", level: "info", message: `md-log linked: ${resolved}`, extra: { file: resolved, backfilled, sessionID } } });
+          return `Linked: ${resolved} to session ${sessionID.slice(0, 8)} \u2014 ${backfilled ? `${backfilled} entries backfilled \u2014 ` : ""}future messages for THIS session will be mirrored. Other sessions stay silent.`;
+        }
+      }),
+      md_log_status: tool({
+        description: "Show md-log link status for this session and directory.",
+        args: {},
+        async execute(_args, ctx) {
+          const sessionID = ctx.sessionID;
+          const own = sessionID ? mdLinks.get(sessionID) : undefined;
+          let countDir = 0;
+          for (const [, meta] of mdLinks)
+            if (meta.directory === directory)
+              countDir++;
+          return `session ${sessionID?.slice(0, 8) ?? "(none)"} -> ${own?.file ?? "(no link)"} | links in this directory: ${countDir}`;
         }
       }),
       md_unlog: tool({
-        description: "Stop mirroring the session to a markdown file.",
+        description: "Stop mirroring THIS session to its markdown file (other sessions unaffected).",
         args: {},
-        async execute() {
-          if (!mdLogFile)
-            return "No file linked";
-          const name = path.basename(mdLogFile);
-          mdLogFile = null;
-          try {
-            fs.writeFileSync(markerPath, JSON.stringify({ file: null }), "utf-8");
-          } catch {}
-          await client.app.log({ body: { service: "learn", level: "info", message: `md-log unlinked: ${name}` } });
-          return `Unlinked: ${name}`;
+        async execute(_args, ctx) {
+          const sessionID = ctx.sessionID;
+          if (!sessionID)
+            return "No session in context";
+          const meta = mdLinks.get(sessionID);
+          if (!meta)
+            return "No file linked for this session";
+          const name = path.basename(meta.file);
+          mdLinks.delete(sessionID);
+          saveMdLinksForDirectory(markerPath, directory);
+          await client.app.log({ body: { service: "learn", level: "info", message: `md-log unlinked: ${name}`, extra: { sessionID } } });
+          return `Unlinked: ${name} from session ${sessionID.slice(0, 8)} (other sessions unaffected)`;
         }
       }),
       write_mermaid: tool({