@bojackduy/opencode-learn 1.2.1 → 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({

package/dist/tui.js

@@ -453,14 +453,14 @@ function QuizDialog(props) {
                     });
                 }
                 setSelected(m);
-                const correct2 = computeCorrect(eff);
+                const correct = computeCorrect(eff);
                 setFeedback({
-                  correct: correct2,
+                  correct,
                   selectedIndices: eff
                 });
                 if (reason)
                   setNote((prev) => prev ? `${prev} \u2014 ${reason}` : prev);
-                tlog("QuizDialog classify done", eff.join(","), correct2, reason || "");
+                tlog("QuizDialog classify done", eff.join(","), correct, reason || "");
               } else if (inferredValues && inferredValues.length) {
                 const byVal = new Map(options().map((o, i) => [o.value, i + 1]));
                 let idxs = inferredValues.map((v) => byVal.get(v)).filter(Boolean);
@@ -480,15 +480,15 @@ function QuizDialog(props) {
                     });
                 }
                 setSelected(m);
-                const correct2 = computeCorrect(idxs);
+                const correct = computeCorrect(idxs);
                 setFeedback({
-                  correct: correct2,
+                  correct,
                   selectedIndices: idxs
                 });
               } else {
-                const correct2 = typeof semanticCorrect === "boolean" ? semanticCorrect : false;
+                const correct = typeof semanticCorrect === "boolean" ? semanticCorrect : false;
                 setFeedback({
-                  correct: correct2,
+                  correct,
                   selectedIndices: []
                 });
                 if (reason)
@@ -1722,13 +1722,13 @@ function QuizBatchDialog(props) {
                   if (eff.length !== inferred.length)
                     tlog("QuizBatchDialog classify enforce single", inferred.join(","), "->", eff.join(","));
                   const mm = new Map;
-                  for (const idx2 of eff) {
-                    const opt = cur().options[idx2 - 1];
+                  for (const idx of eff) {
+                    const opt = cur().options[idx - 1];
                     if (opt)
-                      mm.set(`opt:${idx2 - 1}`, {
+                      mm.set(`opt:${idx - 1}`, {
                         label: opt.label,
                         value: opt.value,
-                        index: idx2
+                        index: idx
                       });
                   }
                   setSelected(mm);
@@ -2667,12 +2667,12 @@ var tui = async (api) => {
       data.sessionID = curSid;
     try {
       const cur = api.route?.current;
-      const curSid2 = cur?.params?.sessionID || cur?.sessionID;
-      if (curSid2 && data.sessionID && data.sessionID !== curSid2) {
+      const curSid = cur?.params?.sessionID || cur?.sessionID;
+      if (curSid && data.sessionID && data.sessionID !== curSid) {
         const anyState = api.state;
         const exists = anyState.session?.get ? anyState.session.get(data.sessionID) : undefined;
         if (!exists)
-          data.sessionID = curSid2;
+          data.sessionID = curSid;
       }
     } catch {}
     current = {

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "1.2.1",
-  "description": "Pi learn system for OpenCode \u2014 Socratic teaching, graded quiz, Obsidian md_log, and visual makers. Port of amosblomqvist/learn (video: How I Use AI to Learn Things) to OpenCode.",
+  "version": "1.2.2",
+  "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",
   "private": false,

package/plugins/learn.ts

@@ -136,24 +136,76 @@ function decodeQuizText(s: string | undefined): string | undefined {
 
 // ────────────────────────────────────────────────────────────────────────────
 // md-log helpers (ported from .pi/extensions/md-log.ts)
+// 1-1-1 model: session : link : log file. No global file.
 // ────────────────────────────────────────────────────────────────────────────
-let mdLogFile: string | null = null
-let mdLogWriteLock: Promise<void> = Promise.resolve()
-function withMdLock<T>(fn: () => T | Promise<T>): Promise<T> {
-  const prev = mdLogWriteLock
+type MdLinkMeta = { file: string; directory: string; linkedAt: number }
+const mdLinks = new Map<string, MdLinkMeta>() // sessionID -> link
+const mdFileLocks = new Map<string, Promise<void>>()
+function withMdFileLock<T>(file: string, fn: () => T | Promise<T>): Promise<T> {
+  const prev = mdFileLocks.get(file) ?? Promise.resolve()
   let release!: () => void
-  mdLogWriteLock = new Promise<void>(r => { release = r })
+  const next = new Promise<void>(r => { release = r })
+  mdFileLocks.set(file, next)
   return prev.then(fn).finally(() => release())
 }
-function appendToMdLog(text: string) {
-  if (!mdLogFile) return
+// Back-compat alias used by older call sites during migration (per-file lock)
+function withMdLock<T>(fn: () => T | Promise<T>): Promise<T> {
+  // Fallback: no file context — run directly (callers should migrate to withMdFileLock)
+  return Promise.resolve().then(fn)
+}
+function getMdFile(sessionID: string | undefined): string | undefined {
+  if (!sessionID) return undefined
+  return mdLinks.get(sessionID)?.file
+}
+function appendToMdLogForSession(sessionID: string | undefined, text: string) {
+  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 ? "\n\n" : ""
-    fs.writeFileSync(mdLogFile, current + prefix + text + "\n", "utf-8")
+    fs.writeFileSync(file, current + prefix + text + "\n", "utf-8")
   } catch {}
 }
+function loadMdLinks(markerPath: string, directory: string) {
+  try {
+    if (!fs.existsSync(markerPath)) return 0
+    const data = JSON.parse(fs.readFileSync(markerPath, "utf-8"))
+    // Legacy shape {file} — do NOT auto-migrate (would bleed). Back up and start empty.
+    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 as any)?.links ?? {}
+    let n = 0
+    for (const [ses, v] of Object.entries<any>(links)) {
+      const f = (v as any)?.file ?? (typeof v === "string" ? v : undefined)
+      if (typeof ses === "string" && typeof f === "string" && fs.existsSync(f)) {
+        mdLinks.set(ses, { file: f, directory: (v as any)?.directory || directory, linkedAt: (v as any)?.linkedAt || Date.now() })
+        n++
+      }
+    }
+    return n
+  } catch { return 0 }
+}
+function saveMdLinksForDirectory(markerPath: string, directory: string) {
+  try {
+    const out: Record<string, { file: string; directory: string; linkedAt: number }> = {}
+    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: any[]): string | undefined {
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0) return c
+  }
+  return undefined
+}
 function callout(type: string, title: string, bodyLines: string[]) {
   const lines = [`> [!${type}] ${title}`]
   for (const line of bodyLines) lines.push(line.length === 0 ? ">" : `> ${line}`)
@@ -202,7 +254,8 @@ function answerCalloutAsk(details: any): string {
   return callout("example", "Answer", body)
 }
 async function backfillMdLog(client: any, sessionID: string, directory: string): Promise<number> {
-  if (!mdLogFile || !sessionID) return 0
+  const mdFile = getMdFile(sessionID)
+  if (!mdFile || !sessionID) return 0
   try {
     const res: any = await client.session.messages({ path: { id: sessionID }, query: { directory } })
     const data: any = res?.data ?? res
@@ -286,15 +339,16 @@ async function backfillMdLog(client: any, sessionID: string, directory: string):
       }
     }
     if (blocks.length) {
+      const mdFile2 = getMdFile(sessionID) || mdFile
       let current = ""
-      try { if (fs.existsSync(mdLogFile)) current = fs.readFileSync(mdLogFile, "utf-8") } catch {}
+      try { if (fs.existsSync(mdFile2)) current = fs.readFileSync(mdFile2, "utf-8") } catch {}
       // If file empty, overwrite; else append with separator (preserve user notes)
       if (current.trim().length === 0) {
-        fs.writeFileSync(mdLogFile, blocks.join("\n\n") + "\n", "utf-8")
+        fs.writeFileSync(mdFile2, blocks.join("\n\n") + "\n", "utf-8")
       } else {
         // Avoid duplicating if already contains same session text
         const prefix = current.trim().length > 0 ? "\n\n" : ""
-        fs.writeFileSync(mdLogFile, current + prefix + blocks.join("\n\n") + "\n", "utf-8")
+        fs.writeFileSync(mdFile2, current + prefix + blocks.join("\n\n") + "\n", "utf-8")
       }
     }
     return blocks.length
@@ -445,23 +499,22 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
 // Plugin definition
 // ────────────────────────────────────────────────────────────────────────────
 const server: Plugin = async ({ client, directory }) => {
-  // Try to restore md-log file from a marker file if exists
+  // 1-1-1: restore session->file links for this directory (same session resumes, different session stays silent)
   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 {}
 
   // Session-scoped visual state (one per plugin instance; subagents get separate plugin instances per session, so isolation is natural)
   let mermaidSession: { workDir: string; bodyPath: string } | null = null
   let svgSession: { workDir: string; bodyPath: string } | null = null
 
-  // md-log dedup state (per plugin instance, survives across sessions but mdLogFile is global)
+  // md-log dedup state keyed by session to avoid cross-session suppression (1-1-1)
   const loggedTextPartIds = new Set<string>()
   const loggedToolCallIds = new Set<string>()
   const messageIdToRole = new Map<string, string>()
+  const mdKey = (ses: string | undefined, id: string) => `${ses || "?"}:${id}`
 
   // ── Classify watcher: note → inferred options (learner-easy) — LLM-backed, not heuristic-only
   function heuristicClassify(note: string, options: Array<{ label: string; value?: string }>, multiSelect?: boolean): number[] {
@@ -704,19 +757,23 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
                 const dk = !!r?.dontKnow
                 const ok = !dk && si.length === (j.correctIndices||[]).length && si.every((i:number)=>cs.has(i))
                 const note = r?.note ? `\nNote: ${r.note}` : ""
-                if (mdLogFile) {
+                if (getMdFile(j.sessionID)) {
                   const details = { status: "completed" as const, answers: r?.answers || [], correct: ok, correctIndices: j.correctIndices || [], explanation: j.explanation, dontKnow: dk, note: r?.note }
-                  void withMdLock(() => appendToMdLog(answerCalloutQuiz(details)))
+                  const sesJ = j.sessionID as string
+                  const fJ = getMdFile(sesJ)!
+                  void withMdFileLock(fJ, () => appendToMdLogForSession(sesJ, answerCalloutQuiz(details)))
                 }
                 return dk ? `[quiz answered] "${j.question}" -> I don't know.\nCorrect: ${cstr}\nExplanation: ${j.explanation}${note}` : `[quiz answered] "${j.question}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.\nCorrect: ${cstr}\nExplanation: ${j.explanation}${note}`
               } else if (j.type === "quiz_batch") {
                 const results = (r as any)?.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" as const, answers: x.answers || [], correct: !!x.correct, correctIndices: qq.correctIndices || [], explanation: qq.explanation || "", dontKnow: !!x.dontKnow, note: x.note }
-                    void withMdLock(() => appendToMdLog(answerCalloutQuiz(details)))
+                    const sesJ = j.sessionID as string
+                    const fJ = getMdFile(sesJ)!
+                    void withMdFileLock(fJ, () => appendToMdLogForSession(sesJ, answerCalloutQuiz(details)))
                   }
                 }
                 const lines = (j.quizzes || []).map((qq:any, i:number) => {
@@ -756,9 +813,11 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
       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 as any)?.sessionID, (output as any)?.message?.sessionID)
+        const mdFile = getMdFile(ses)
+        if (!mdFile || !ses) return
         const msg: any = (output as any).message
         const parts: any[] = (output as any).parts ?? []
         let text = ""
@@ -770,25 +829,31 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
         // Skip system-injected quiz/batch answer prompts — they are mirrored as beautiful callouts via watchAndInject, not as plain user quotes
         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)) return
-        loggedTextPartIds.add(mid)
-        await withMdLock(() => appendToMdLog(userBlock(text)))
+        const mkey = mdKey(ses, mid)
+        if (loggedTextPartIds.has(mkey)) return
+        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 as any)?.sessionID)
+        const mdFile = getMdFile(ses)
+        if (!mdFile || !ses) return
         const text = (output as any).text?.trim()
         if (!text) return
         const partID = (input as any).partID
-        if (partID && loggedTextPartIds.has(partID)) return
-        if (partID) loggedTextPartIds.add(partID)
-        await withMdLock(() => appendToMdLog(assistantBlock(stripSkillBlocks(text))))
+        const pkey = partID ? mdKey(ses, partID) : undefined
+        if (pkey && loggedTextPartIds.has(pkey)) return
+        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 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.
@@ -798,53 +863,61 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
           const ctx2 = args.details?.trim() || undefined
           const opts = Array.isArray(args.options) ? args.options : []
           const callID = (input as any).callID
-          if (callID && loggedToolCallIds.has(`q:${callID}`)) return
-          if (callID) loggedToolCallIds.add(`q:${callID}`)
-          if (q) await withMdLock(() => appendToMdLog(questionCallout("Question", q, ctx2, opts)))
+          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)))
         }
       } catch {}
     },
     "tool.execute.after": async (input, output) => {
-      if (!mdLogFile) return
       try {
+        const ses = extractHookSessionID((input as any)?.sessionID)
+        const mdFile = getMdFile(ses)
+        if (!mdFile || !ses) return
         const toolName = (input as any).tool
         const callID = (input as any).callID
-        if (callID && loggedToolCallIds.has(`answer:${callID}`)) return
+        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" }
-          await withMdLock(() => appendToMdLog(answerCalloutAsk(details)))
-          if (callID) loggedToolCallIds.add(`answer:${callID}`)
+          await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, answerCalloutAsk(details)))
+          if (akey) loggedToolCallIds.add(akey)
         }
       } catch {}
     },
-    // Mirror session to markdown file (best-effort, mirrors pi's md-log)
+    // Mirror session to markdown file (best-effort, mirrors pi's md-log) — 1-1-1 gated
     event: async ({ event }) => {
-      if (!mdLogFile) return
       const t = (event as any).type as string
       const props = (event as any).properties ?? {}
       try {
         if (t === "message.updated") {
           const info: any = props.info
           if (info?.id && info?.role) messageIdToRole.set(info.id, info.role)
+          return
         } else if (t === "message.part.updated") {
           const part: any = props.part
           const delta: string | undefined = props.delta
           if (!part || !part.id) return
+          const ses = extractHookSessionID(part.sessionID, (props as any)?.sessionID, (props.info as any)?.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)) return
+            const pkey = mdKey(ses, part.id)
+            if (loggedTextPartIds.has(pkey)) return
             const text = (part.text || "").trim()
             if (!text) return
             const role = messageIdToRole.get(part.messageID)
             if (role === "user") return
             // Fallback for assistant when experimental.text.complete not fired
-            loggedTextPartIds.add(part.id)
-            await withMdLock(() => appendToMdLog(assistantBlock(stripSkillBlocks(text))))
+            loggedTextPartIds.add(pkey)
+            await withMdFileLock(mdFile, () => appendToMdLogForSession(ses, assistantBlock(stripSkillBlocks(text))))
           }
         }
       } catch {}
@@ -905,6 +978,7 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
           }
           try { fs.writeFileSync(pendingPath, JSON.stringify(payload), "utf8"); slog("quiz wrote durably", pendingPath, "alive", tuiAlive) } catch (e) { slog("quiz write failed", String(e)) }
           try { await (ctx as any).metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { pendingId: id } }) } catch {}
+          const quizSes = (ctx as any).sessionID as string | undefined
           watchAndInject(client, directory, id, (ctx as any).sessionID, (r: any) => {
               const dk = !!r?.dontKnow
               const sel = (r?.answers || []).map((a: any) => `${a.index}. ${a.label}`).join(", ") || "(none)"
@@ -912,7 +986,8 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
               const si = (r?.answers || []).map((a: any) => a.index)
               const ok = !dk && si.length === correctIndices.length && si.every((i: number) => cs.has(i))
               const note = r?.note ? `\nNote: ${r.note}` : ""
-              if (mdLogFile) {
+              const qf = quizSes ? getMdFile(quizSes) : undefined
+              if (qf && quizSes) {
                 const details = {
                   status: "completed" as const,
                   answers: r?.answers || [],
@@ -922,15 +997,18 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
                   dontKnow: dk,
                   note: r?.note,
                 }
-                void withMdLock(() => appendToMdLog(answerCalloutQuiz(details)))
+                void withMdFileLock(qf, () => appendToMdLogForSession(quizSes, answerCalloutQuiz(details)))
               }
               return dk
                 ? `[quiz answered] "${qFixed}" -> I don't know (genuine gap).\nCorrect: ${correctStr}\nExplanation: ${eFixed}${note}`
                 : `[quiz answered] "${qFixed}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.\nCorrect: ${correctStr}\nExplanation: ${eFixed}${note}`
             })
-          // Always mirror question with TRUE shuffled order (pi: tool_execution_update)
-          if (mdLogFile) {
-            try { await withMdLock(() => appendToMdLog(questionCallout("Quiz", qFixed, dFixed?.trim() || undefined, options.map((o) => ({ label: o.label }))))) } catch {}
+          // Always mirror question with TRUE shuffled order (pi: tool_execution_update) — 1-1-1 gated
+          {
+            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 — waiting for your answer in the popup. I'll continue once you respond.]`
@@ -950,7 +1028,10 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
             const trimmed = (raw as string).trim()
             if (trimmed === "0" || trimmed.toLowerCase() === "i don't know") {
               const msg = `User selected "I don't know" — genuine gap, not a guess.\nCorrect: ${correctStr}\nExplanation: ${eFixed}`
-              if (mdLogFile) await withMdLock(() => appendToMdLog(callout("question", "Quiz — 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 — 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)
@@ -961,7 +1042,10 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
             const verdict = correct ? "correctly" : "incorrectly"
             const result = `User answered ${verdict}.\nSelected: ${selectedStr}\nCorrect: ${correctStr}\nExplanation: ${eFixed}`
               ;(ctx as any).metadata?.({ title: correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", metadata: { correct, correctIndices, explanation: eFixed } })
-            if (mdLogFile) await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", [`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 — correct ✓" : "Quiz — incorrect ✗", [`Q: ${qFixed}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, eFixed])))
+            }
             return result
           }
           const instruction = [
@@ -1029,36 +1113,42 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
           const file = path.join(pendingDirPath, `quiz_batch-${id}.json`)
           try { fs.writeFileSync(file, JSON.stringify(payload), "utf8"); slog("quiz_batch wrote durably", file, "alive", isAlive) } catch (e) { slog("quiz_batch write failed", String(e)) }
           try { await (ctx as any).metadata?.({ title: `Quiz batch ${normalized.length}`, metadata: { pendingId: id } }) } catch {}
-          // Mirror each question in batch as a beautiful callout (like single quiz)
-          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: any) => ({ label: o.label })))) ) } catch {}
+          const batchSes = (ctx as any).sessionID as string | undefined
+          // Mirror each question in batch as a beautiful callout (like single quiz) — 1-1-1 gated
+          {
+            const bf = batchSes ? getMdFile(batchSes) : undefined
+            if (bf && batchSes) {
+              for (let i = 0; i < normalized.length; i++) {
+                const q = normalized[i]
+                const label = `Quiz ${i + 1}/${normalized.length}`
+                try { await withMdFileLock(bf, () => appendToMdLogForSession(batchSes, questionCallout(label, q.question, q.details?.trim() || undefined, q.options.map((o: any) => ({ label: o.label }))))) } catch {}
+              }
             }
           }
           watchAndInject(client, directory, id, (ctx as any).sessionID, (r: any) => {
               const results = r?.results || []
               // Mirror each answer as a beautiful callout (like single quiz) — not just plain text
-              if (mdLogFile) {
-                for (let i = 0; i < normalized.length; i++) {
-                  const q = normalized[i]
-                  const x = results[i] || {}
-                  const details = {
-                    status: "completed" as const,
-                    answers: x.answers || [],
-                    correct: !!x.correct,
-                    correctIndices: q.correctIndices || [],
-                    explanation: q.explanation || "",
-                    dontKnow: !!x.dontKnow,
-                    note: x.note,
+              {
+                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" as const,
+                      answers: x.answers || [],
+                      correct: !!x.correct,
+                      correctIndices: q.correctIndices || [],
+                      explanation: q.explanation || "",
+                      dontKnow: !!x.dontKnow,
+                      note: x.note,
+                    }
+                    // Use same callout helper as single quiz but with batch label context
+                    try {
+                      // withMdFileLock is async, but watchAndInject buildText is sync — queue without await and let it flush
+                      void withMdFileLock(bf, () => appendToMdLogForSession(batchSes, answerCalloutQuiz(details)))
+                    } catch {}
                   }
-                  const label = `Quiz ${i + 1}/${normalized.length}`
-                  // Use same callout helper as single quiz but with batch label context
-                  try {
-                    // withMdLock is async, but watchAndInject buildText is sync — queue without await and let it flush
-                    void withMdLock(() => appendToMdLog(answerCalloutQuiz(details)))
-                  } catch {}
                 }
               }
               const lines = results.map((x: any, i: number) => {
@@ -1076,39 +1166,59 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
           }
       }),
 
-      // ── md_log: link a markdown file ───────────────────────────────────
+      // ── md_log: link a markdown file — 1-1-1 session:link:file ──────────
       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 as any).sessionID as string | undefined
+          if (!sessionID) return `md_log error: no sessionID in context — 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 {}
-          // Backfill history for this session (like pi: ctx.sessionManager.getEntries() parent chain)
+          // Enforce 1-1-1: one file linked to at most one session
+          for (const [ses, meta] of mdLinks) {
+            if (meta.file === resolved && ses !== sessionID) {
+              return `File already linked to session ${ses.slice(0,8)} — 1-1-1 violation. Copy to a new file or md_unlog that session first.`
+            }
+          }
+          mdLinks.set(sessionID, { file: resolved, directory, linkedAt: Date.now() })
+          saveMdLinksForDirectory(markerPath, directory)
+          // Backfill history for this session only
           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)} — ${backfilled ? `${backfilled} entries backfilled — ` : ""}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 as any).sessionID as string | undefined
-          if (sessionID) {
-            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 } } })
-          return `Linked: ${resolved} — ${backfilled ? `${backfilled} entries backfilled — ` : ""}future messages will be mirrored. View it rendered in Obsidian for LaTeX/math.`
+          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 as any).sessionID as string | undefined
+          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)`
         },
       }),