@bojackduy/opencode-learn 1.4.0 → 1.4.2

package/dist/server.js

@@ -210,7 +210,7 @@ function loadMdLinks(markerPath, directory) {
     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() });
+        mdLinks.set(ses, { file: f, directory: v?.directory || directory, linkedAt: v?.linkedAt || Date.now(), backfilledUntil: v?.backfilledUntil });
         n++;
       }
     }
@@ -355,19 +355,33 @@ function answerCalloutAsk(details) {
     body.push("(no answer)");
   return callout("example", "Answer", body);
 }
-async function backfillMdLog(client, sessionID, directory) {
+async function backfillMdLog(client, sessionID, directory, markerPath) {
   const mdFile = getMdFile(sessionID);
   if (!mdFile || !sessionID)
     return 0;
+  const linkMeta = mdLinks.get(sessionID);
+  const already = linkMeta?.backfilledUntil;
   try {
     const res = await client.session.messages({ path: { id: sessionID }, query: { directory } });
     const data = res?.data ?? res;
-    const entries = Array.isArray(data) ? data : [];
-    if (!entries.length)
+    const allEntries = Array.isArray(data) ? data : [];
+    if (!allEntries.length)
       return 0;
+    let entries = allEntries;
+    if (already) {
+      const idx = allEntries.findIndex((e) => e?.info?.id === already);
+      if (idx < 0)
+        return 0;
+      entries = allEntries.slice(idx + 1);
+      if (!entries.length)
+        return 0;
+    }
     const blocks = [];
+    let lastID = already;
     for (const entry of entries) {
       const info = entry.info;
+      if (info?.id)
+        lastID = info.id;
       const parts = entry.parts ?? [];
       if (!info || !info.role)
         continue;
@@ -487,6 +501,10 @@ async function backfillMdLog(client, sessionID, directory) {
 `, "utf-8");
       }
     }
+    if (lastID && lastID !== already) {
+      mdLinks.set(sessionID, { ...linkMeta, file: mdFile, directory, backfilledUntil: lastID });
+      saveMdLinksForDirectory(markerPath, directory);
+    }
     return blocks.length;
   } catch (e) {
     slog("backfill failed", String(e));
@@ -522,6 +540,40 @@ function randomId() {
   } catch {}
   return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
 }
+function ownerLockPath(dir, id) {
+  return path.join(dir, `owner-${id}.lock`);
+}
+function acquireOwnerLock(dir, id) {
+  const p = ownerLockPath(dir, id);
+  const payload = JSON.stringify({ pid: process.pid, at: Date.now() });
+  try {
+    fs.writeFileSync(p, payload, { flag: "wx" });
+    return true;
+  } catch {}
+  try {
+    const age = Date.now() - fs.statSync(p).mtimeMs;
+    if (age > 15000) {
+      fs.writeFileSync(p, payload, "utf8");
+      return true;
+    }
+  } catch {
+    try {
+      fs.writeFileSync(p, payload, { flag: "wx" });
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function refreshOwnerLock(dir, id) {
+  try {
+    fs.writeFileSync(ownerLockPath(dir, id), JSON.stringify({ pid: process.pid, at: Date.now() }), "utf8");
+  } catch {}
+}
+function releaseOwnerLock(dir, id) {
+  try {
+    fs.unlinkSync(ownerLockPath(dir, id));
+  } catch {}
+}
 var activeWatchers = new Map;
 function watchAndInject(client, directory, id, sessionID, buildText) {
   slog("watchAndInject start", id, sessionID);
@@ -531,6 +583,10 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
   }
   activeWatchers.get(id)?.();
   const dir = pendingDir(directory);
+  if (!acquireOwnerLock(dir, id)) {
+    slog("watchAndInject lock busy, another process owns this id", id);
+    return;
+  }
   const respPath = path.join(dir, `response-${id}.json`);
   const claimPath = path.join(dir, `response-${id}.claim-${process.pid}.json`);
   const pendingCandidates = [path.join(dir, `quiz-${id}.json`), path.join(dir, `quiz_batch-${id}.json`)];
@@ -548,6 +604,7 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
       clearInterval(pollTimer);
     if (activeWatchers.get(id) === closeWatcher)
       activeWatchers.delete(id);
+    releaseOwnerLock(dir, id);
   };
   activeWatchers.set(id, closeWatcher);
   const fire = async (attempt = 0) => {
@@ -666,6 +723,7 @@ function watchAndInject(client, directory, id, sessionID, buildText) {
     watcher.on("error", () => {});
   } catch {}
   pollTimer = setInterval(() => {
+    refreshOwnerLock(dir, id);
     if (fs.existsSync(respPath)) {
       fire();
       return;
@@ -1495,11 +1553,13 @@ Explanation: ${eFixed}`;
               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.`;
             }
           }
-          mdLinks.set(sessionID, { file: resolved, directory, linkedAt: Date.now() });
+          const existingMeta = mdLinks.get(sessionID);
+          const preservedWatermark = existingMeta?.file === resolved ? existingMeta.backfilledUntil : undefined;
+          mdLinks.set(sessionID, { file: resolved, directory, linkedAt: Date.now(), backfilledUntil: preservedWatermark });
           saveMdLinksForDirectory(markerPath, directory);
           let backfilled = 0;
           try {
-            backfilled = await backfillMdLog(client, sessionID, directory);
+            backfilled = await backfillMdLog(client, sessionID, directory, markerPath);
           } catch (e) {
             slog("backfill error", String(e));
           }

package/dist/tui.js

@@ -2636,13 +2636,69 @@ var tui = async (api) => {
       return false;
     }
   };
+  const popupLockPath = (id) => path.join(pendingDir, `opening-${id}.lock`);
+  const tryClaimPopup = (id) => {
+    const p = popupLockPath(id);
+    try {
+      fs.writeFileSync(p, String(process.pid), {
+        flag: "wx"
+      });
+      return true;
+    } catch {}
+    try {
+      const age = Date.now() - fs.statSync(p).mtimeMs;
+      if (age > 20000) {
+        fs.writeFileSync(p, String(process.pid), "utf8");
+        return true;
+      }
+    } catch {
+      try {
+        fs.writeFileSync(p, String(process.pid), {
+          flag: "wx"
+        });
+        return true;
+      } catch {}
+    }
+    return false;
+  };
+  const refreshPopupClaim = (id) => {
+    try {
+      fs.writeFileSync(popupLockPath(id), String(process.pid), "utf8");
+    } catch {}
+  };
+  const releasePopupClaim = (id) => {
+    try {
+      fs.unlinkSync(popupLockPath(id));
+    } catch {}
+  };
   const processPending = () => {
     const curSid = getCurrentSessionID();
     if (!curSid)
       return;
     let current = currentBySession.get(curSid);
-    if (current)
-      return;
+    if (current) {
+      const pendingStillExists = (() => {
+        try {
+          return fs.readdirSync(pendingDir).some((f) => f === `quiz-${current.id}.json` || f === `quiz_batch-${current.id}.json`);
+        } catch {
+          return true;
+        }
+      })();
+      if (!pendingStillExists) {
+        tlog("processPending stale current cleared (pending gone)", current.id);
+        releasePopupClaim(current.id);
+        currentBySession.delete(curSid);
+        current = undefined;
+      } else if (api.ui.dialog.open) {
+        refreshPopupClaim(current.id);
+        return;
+      } else {
+        tlog("processPending stale current cleared (dialog no longer open)", current.id);
+        releasePopupClaim(current.id);
+        currentBySession.delete(curSid);
+        current = undefined;
+      }
+    }
     if (api.ui.dialog.open)
       return;
     let files = [];
@@ -2662,7 +2718,8 @@ var tui = async (api) => {
         return null;
       }
     }).filter(Boolean).filter((x) => !hasAnswerArtifact(x.j.id));
-    const pick = matching.find((x) => x.j.sessionID === curSid) || matching.find((x) => !x.j.sessionID);
+    const byNewest = [...matching].sort((a, b) => (b.j?.timestamp || 0) - (a.j?.timestamp || 0));
+    const pick = byNewest.find((x) => x.j.sessionID === curSid) || byNewest.find((x) => !x.j.sessionID);
     if (!pick)
       return;
     const file = pick.f;
@@ -2694,6 +2751,10 @@ var tui = async (api) => {
           data.sessionID = curSid;
       }
     } catch {}
+    if (!tryClaimPopup(data.id)) {
+      tlog("processPending popup already claimed elsewhere", data.id);
+      return;
+    }
     current = {
       id: data.id,
       type: data.type
@@ -2799,6 +2860,7 @@ var tui = async (api) => {
           }
         }
       } catch {}
+      releasePopupClaim(answerId);
       api.ui.dialog.clear();
       currentBySession.delete(curSid);
       setTimeout(processPending, 150);
@@ -2858,6 +2920,7 @@ var tui = async (api) => {
           } catch {}
         }
       } catch {}
+      releasePopupClaim(data.id);
       api.ui.dialog.clear();
       currentBySession.delete(curSid);
       setTimeout(processPending, 150);
@@ -2880,6 +2943,7 @@ var tui = async (api) => {
       }));
     } else {
       tlog("processPending unknown", data.type, data.id);
+      releasePopupClaim(data.id);
       try {
         fs.unlinkSync(full);
       } catch {}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-learn",
-  "version": "1.4.0",
+  "version": "1.4.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",

package/plugins/learn-tui.tsx

@@ -787,18 +787,61 @@ export const tui: TuiPlugin = async (api) => {
     }
   }
 
+  // Cross-process single-popup lock: if the same session is open in more than one opencode
+  // window, each runs its own copy of this TUI plugin and independently polls the same
+  // pendingDir. Without this, two windows could both open the SAME quiz dialog and let the
+  // user answer twice — the second answer overwrites the (already-consumed) response file with
+  // nobody left watching it, so it silently rots as an orphan and never reaches the session
+  // ("the next quiz doesn't inject"). Only the window that wins this lock may show the dialog.
+  const popupLockPath = (id: string) => path.join(pendingDir, `opening-${id}.lock`)
+  const tryClaimPopup = (id: string): boolean => {
+    const p = popupLockPath(id)
+    try { fs.writeFileSync(p, String(process.pid), { flag: "wx" }); return true } catch {}
+    try {
+      const age = Date.now() - fs.statSync(p).mtimeMs
+      if (age > 20000) { fs.writeFileSync(p, String(process.pid), "utf8"); return true }
+    } catch {
+      try { fs.writeFileSync(p, String(process.pid), { flag: "wx" }); return true } catch {}
+    }
+    return false
+  }
+  const refreshPopupClaim = (id: string) => { try { fs.writeFileSync(popupLockPath(id), String(process.pid), "utf8") } catch {} }
+  const releasePopupClaim = (id: string) => { try { fs.unlinkSync(popupLockPath(id)) } catch {} }
+
   const processPending = () => {
     const curSid = getCurrentSessionID()
     if (!curSid) return
     let current = currentBySession.get(curSid) as { id: string; type: string } | undefined
-    if (current) return
+    if (current) {
+      // Self-heal: the tracked dialog may have been dismissed through a path other than
+      // done()/cancel() (session/tab switch, TUI reconnect, dialog replaced externally),
+      // or its pending file may have been consumed externally. A stuck entry would block
+      // ALL future quizzes for this session forever — release it and rediscover below.
+      const pendingStillExists = (() => { try { return fs.readdirSync(pendingDir).some((f) => f === `quiz-${current!.id}.json` || f === `quiz_batch-${current!.id}.json`) } catch { return true } })()
+      if (!pendingStillExists) {
+        tlog("processPending stale current cleared (pending gone)", current.id)
+        releasePopupClaim(current.id)
+        currentBySession.delete(curSid)
+        current = undefined
+      } else if (api.ui.dialog.open) { refreshPopupClaim(current.id); return }
+      else {
+        tlog("processPending stale current cleared (dialog no longer open)", current.id)
+        releasePopupClaim(current.id)
+        currentBySession.delete(curSid)
+        current = undefined
+      }
+    }
     if (api.ui.dialog.open) return
     let files: string[] = []
     try { files = fs.readdirSync(pendingDir).filter(f => f.endsWith(".json") && !f.startsWith("response-") && !f.startsWith(".") && !f.startsWith("classify")).sort() } catch { return }
     // Session-distinct: only show pending for current session.
     // Skip answered-pending (a response file exists, server is consuming): prevents re-popup after answer.
     const matching = files.map(f => { try { const j = JSON.parse(fs.readFileSync(path.join(pendingDir, f), "utf8")) as any; return { f, j } } catch { return null } }).filter(Boolean).filter(x => !hasAnswerArtifact(x!.j.id)) as Array<{f: string, j: any}>
-    const pick = matching.find(x => x.j.sessionID === curSid) || matching.find(x => !x.j.sessionID)
+    // Newest-first: when several quizzes stack up for the same session (e.g. earlier ones
+    // answered manually in chat after a popup failure), the LATEST quiz is the live one the
+    // agent is waiting on. Alphabetical order would keep re-showing the oldest stuck quiz.
+    const byNewest = [...matching].sort((a, b) => (((b as any).j?.timestamp || 0) as number) - (((a as any).j?.timestamp || 0) as number))
+    const pick = byNewest.find(x => x.j.sessionID === curSid) || byNewest.find(x => !x.j.sessionID)
     if (!pick) return
     const file = pick.f
     const full = path.join(pendingDir, file)
@@ -817,6 +860,12 @@ export const tui: TuiPlugin = async (api) => {
         if (!exists) (data as any).sessionID = curSid
       }
     } catch {}
+    if (!tryClaimPopup(data.id)) {
+      // Another opencode window (same session open elsewhere) already owns this popup —
+      // don't show a second copy of it here, and don't answer it from this process.
+      tlog("processPending popup already claimed elsewhere", data.id)
+      return
+    }
     current = { id: data.id, type: data.type }
     currentBySession.set(curSid, current)
     const done = async (result: any) => {
@@ -884,6 +933,7 @@ export const tui: TuiPlugin = async (api) => {
       } catch {}
       // Keep the pending payload until the server confirms injection. It is the recovery context
       // needed to rebuild the prompt if either process exits after the answer is written.
+      releasePopupClaim(answerId)
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)
@@ -918,13 +968,14 @@ export const tui: TuiPlugin = async (api) => {
         }
       } catch {}
       // Keep the pending payload until the server consumes the cancellation response.
+      releasePopupClaim(data!.id)
       api.ui.dialog.clear()
       currentBySession.delete(curSid)
       setTimeout(processPending, 150)
     }
     if (data.type === "quiz") { tlog("processPending quiz", data.id); api.ui.dialog.replace(() => <QuizDialog api={api} request={data as QuizPending} onSubmit={done} onCancel={cancel} />) }
     else if (data.type === "quiz_batch") { tlog("processPending quiz_batch", data.id, (data as QuizBatchPending).quizzes.length); api.ui.dialog.replace(() => <QuizBatchDialog api={api} request={data as QuizBatchPending} onSubmit={done} onCancel={cancel} />) }
-    else { tlog("processPending unknown", (data as any).type, data.id); try { fs.unlinkSync(full) } catch {}; currentBySession.delete(curSid); return }
+    else { tlog("processPending unknown", (data as any).type, data.id); releasePopupClaim(data.id); try { fs.unlinkSync(full) } catch {}; currentBySession.delete(curSid); return }
     try { api.ui.dialog.setSize("large") } catch {}
   }
 

package/plugins/learn.ts

@@ -138,7 +138,7 @@ 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.
 // ────────────────────────────────────────────────────────────────────────────
-type MdLinkMeta = { file: string; directory: string; linkedAt: number }
+type MdLinkMeta = { file: string; directory: string; linkedAt: number; backfilledUntil?: string }
 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> {
@@ -183,7 +183,7 @@ function loadMdLinks(markerPath: string, directory: string) {
     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() })
+        mdLinks.set(ses, { file: f, directory: (v as any)?.directory || directory, linkedAt: (v as any)?.linkedAt || Date.now(), backfilledUntil: (v as any)?.backfilledUntil })
         n++
       }
     }
@@ -272,17 +272,32 @@ function answerCalloutAsk(details: any): string {
   if (body.length === 0) body.push("(no answer)")
   return callout("example", "Answer", body)
 }
-async function backfillMdLog(client: any, sessionID: string, directory: string): Promise<number> {
+async function backfillMdLog(client: any, sessionID: string, directory: string, markerPath: string): Promise<number> {
   const mdFile = getMdFile(sessionID)
   if (!mdFile || !sessionID) return 0
+  const linkMeta = mdLinks.get(sessionID)
+  const already = linkMeta?.backfilledUntil
   try {
     const res: any = await client.session.messages({ path: { id: sessionID }, query: { directory } })
     const data: any = res?.data ?? res
-    const entries: any[] = Array.isArray(data) ? data : []
-    if (!entries.length) return 0
+    const allEntries: any[] = Array.isArray(data) ? data : []
+    if (!allEntries.length) return 0
+    // Idempotency: skip everything up to (and including) the last message already backfilled,
+    // so re-linking the same file (md_log called again) never re-dumps history already written.
+    let entries = allEntries
+    if (already) {
+      const idx = allEntries.findIndex((e) => e?.info?.id === already)
+      // If the watermark message can't be found (pruned/compacted history), bail out rather
+      // than risk re-appending everything — live hooks still capture new messages going forward.
+      if (idx < 0) return 0
+      entries = allEntries.slice(idx + 1)
+      if (!entries.length) return 0
+    }
     const blocks: string[] = []
+    let lastID: string | undefined = already
     for (const entry of entries) {
       const info: any = entry.info
+      if (info?.id) lastID = info.id
       const parts: any[] = entry.parts ?? []
       if (!info || !info.role) continue
       if (info.role === "user") {
@@ -387,6 +402,12 @@ async function backfillMdLog(client: any, sessionID: string, directory: string):
         fs.writeFileSync(mdFile2, current + prefix + blocks.join("\n\n") + "\n", "utf-8")
       }
     }
+    // Persist the watermark whenever we've examined new entries, even if none produced a block,
+    // so a repeated md_log call never re-scans (and never re-appends) the same history again.
+    if (lastID && lastID !== already) {
+      mdLinks.set(sessionID, { ...(linkMeta as MdLinkMeta), file: mdFile, directory, backfilledUntil: lastID })
+      saveMdLinksForDirectory(markerPath, directory)
+    }
     return blocks.length
   } catch (e) {
     slog("backfill failed", String(e))
@@ -475,6 +496,27 @@ async function waitForResponse(directory: string, id: string, abort: AbortSignal
   })
 }
 
+// Cross-process single-writer lock: multiple opencode processes (separate windows/tabs) can be
+// attached to the same project directory, and each independently re-arms durable pending quizzes
+// on its own startup. Without this, every process spins up its own fs.watch/poll for the same id,
+// which is wasteful and — combined with the TUI-side popup lock below — is what caused a stray
+// duplicate answer to go unwatched (the "second recovered quiz never injects" bug).
+function ownerLockPath(dir: string, id: string) { return path.join(dir, `owner-${id}.lock`) }
+function acquireOwnerLock(dir: string, id: string): boolean {
+  const p = ownerLockPath(dir, id)
+  const payload = JSON.stringify({ pid: process.pid, at: Date.now() })
+  try { fs.writeFileSync(p, payload, { flag: "wx" }); return true } catch {}
+  try {
+    const age = Date.now() - fs.statSync(p).mtimeMs
+    if (age > 15000) { fs.writeFileSync(p, payload, "utf8"); return true }
+  } catch {
+    try { fs.writeFileSync(p, payload, { flag: "wx" }); return true } catch {}
+  }
+  return false
+}
+function refreshOwnerLock(dir: string, id: string) { try { fs.writeFileSync(ownerLockPath(dir, id), JSON.stringify({ pid: process.pid, at: Date.now() }), "utf8") } catch {} }
+function releaseOwnerLock(dir: string, id: string) { try { fs.unlinkSync(ownerLockPath(dir, id)) } catch {} }
+
 // Server-side inject (loopd pattern: host-adapter.ts:100 promptAsync + path.id + body.parts)
 const activeWatchers = new Map<string, () => void>()
 function watchAndInject(client: any, directory: string, id: string, sessionID: string, buildText: (result: any) => string) {
@@ -482,6 +524,7 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
   if (!sessionID) { slog("watchAndInject no sessionID", id); return }
   activeWatchers.get(id)?.()
   const dir = pendingDir(directory)
+  if (!acquireOwnerLock(dir, id)) { slog("watchAndInject lock busy, another process owns this id", id); return }
   const respPath = path.join(dir, `response-${id}.json`)
   const claimPath = path.join(dir, `response-${id}.claim-${process.pid}.json`)
   const pendingCandidates = [path.join(dir, `quiz-${id}.json`), path.join(dir, `quiz_batch-${id}.json`)]
@@ -494,6 +537,7 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
     try { watcher?.close() } catch {}
     if (pollTimer) clearInterval(pollTimer)
     if (activeWatchers.get(id) === closeWatcher) activeWatchers.delete(id)
+    releaseOwnerLock(dir, id)
   }
   activeWatchers.set(id, closeWatcher)
   const fire = async (attempt = 0): Promise<void> => {
@@ -586,6 +630,7 @@ function watchAndInject(client: any, directory: string, id: string, sessionID: s
   // fs.watch is lossy by design. Polling keeps persisted answers moving after a TUI/server restart
   // even when the filesystem event is dropped.
   pollTimer = setInterval(() => {
+    refreshOwnerLock(dir, id)
     if (fs.existsSync(respPath)) { void fire(); return }
     if (!pendingCandidates.some((p) => fs.existsSync(p)) && !fs.existsSync(claimPath)) closeWatcher()
   }, 500)
@@ -1330,11 +1375,16 @@ Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"...","isIDK"
               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() })
+          // Re-linking the SAME file for this session (e.g. md_log called again after a
+          // restart/reconnect) must preserve the backfill watermark — otherwise every re-link
+          // would re-dump the entire session history into the file a second time.
+          const existingMeta = mdLinks.get(sessionID)
+          const preservedWatermark = existingMeta?.file === resolved ? existingMeta.backfilledUntil : undefined
+          mdLinks.set(sessionID, { file: resolved, directory, linkedAt: Date.now(), backfilledUntil: preservedWatermark })
           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)) }
+          try { backfilled = await backfillMdLog(client, sessionID, directory, markerPath) } 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.`
         },