misakanet 2.40.0 → 2.41.1

package/lib/client.js

@@ -107,10 +107,308 @@ window.__ModuleLoader__.load({
 		 * could take. (`kind` is what `openTab` names; `id` is the implementation's identity.)
 		 */
 		var PANEL_KIND = "misakanet-panel";
+		var ROW_ID = "misakanet-mcp";
+
+		/**
+		 * Localization. The dictionaries live in this file rather than in `locale/*.json`: those files are the
+		 * *package metadata* the host reads for the plugin page's title and description (`dsh-app-boot`'s
+		 * `dictionariesOf`), while UI copy goes through `ctx.locale`. Both matter, and they are different
+		 * mechanisms.
+		 *
+		 * `T` is a module-level binding rather than a prop: the host's `bind` keeps a stable identity and reads
+		 * the active locale on every call, so a component that re-renders after a locale switch gets the new
+		 * language from the same function.
+		 */
+		var NS = PANEL_ID;
+		var en = {
+			"guide.description": "What this session asked, what came back, and what you filed",
+			"panel.asked": "What this session asked",
+			"panel.asked.none": "No MisakaNet search has run in this session yet.",
+			"panel.reports": "Reports you filed",
+			"panel.reports.none": "Nothing filed from this session.",
+			"panel.trust": "How much these lessons are trusted",
+			"panel.trust.none": "No lesson surfaced yet.",
+			"panel.activity": "Your activity",
+			"panel.voice": "Voice",
+			"panel.voice.on": "Voice cues: on",
+			"panel.voice.off": "Voice cues: off",
+			"overlay.searching": "Searching…",
+			"overlay.empty": "Type what broke after /misakanet, e.g. /misakanet pip install timeout",
+			"overlay.none": "No lesson covers this yet. Ask the agent to file it (misakanet_submit_intake), or file it at misakanet.org — that is how the next person finds it here.",
+			"overlay.failed": "Search failed: {error} — the library is at misakanet.org; nothing was sent but the query.",
+			"overlay.footnote": "Reads are anonymous. This overlay sends only the query to misakanet.org; your votes and reports are the only other things a page ever sends.",
+			"overlay.close": "Close",
+			"settings.voice": "Play voice cues in this browser",
+			"settings.voice.note": "(the same switch the panel shows)",
+			"settings.density": "How much MisakaNet shows",
+			"settings.density.compact": "compact — title and domain",
+			"settings.density.full": "full — plus lesson id and description",
+			"settings.endpoint": "MCP endpoint",
+			"settings.save": "Save",
+			"settings.saving": "Saving…",
+			"settings.saved": "Saved — applies on the next host start.",
+			"settings.refused": "The host refused the write.",
+			"settings.writeFailed": "Write failed: {error}",
+			"settings.readonly": "This host does not accept writes for the row from here.",
+			"settings.patchHint": "The MCP endpoint, transport and timeout live in the profile's cordis.patch.yml, entry id: {row}; this host exposes no writable form for them.",
+			"settings.local": "The two switches above are kept in this browser and never uploaded.",
+			"footer.action": "Copy session summary",
+			"footer.copied": "Copied",
+			"footer.nothing": "Nothing yet",
+			"footer.failed": "Copy failed",
+			"toast.one": "1 lesson",
+			"toast.many": "{n} lessons",
+			"unit.search": "search",
+			"unit.searches": "searches",
+			"unit.lesson": "lesson",
+			"unit.lessons": "lessons",
+			"unit.vote": "vote",
+			"unit.votes": "votes",
+			"unit.report": "report",
+			"unit.reports": "reports",
+			"panel.asked.searching": "searching…",
+			"panel.asked.noMatch": "no lesson matched",
+			"panel.asked.top": "· top: ",
+			"panel.asked.noQuery": "(no query text)",
+			"panel.asked.nothingFound": "nothing found",
+			"panel.asked.voteHelpful": "Helpful",
+			"panel.asked.voteNotHelpful": "not helpful",
+			"panel.asked.voteNone": "not voted",
+			"panel.asked.voteNoLesson": "no lesson",
+			"panel.counters": "this session · counters local to this browser · no account, nothing uploaded but your votes and reports",
+			"panel.report.title": "MisakaNet report",
+			"panel.report.coveredBy": "covered by ",
+			"panel.report.similarity": " (similarity ",
+			"panel.report.pending": "pending report",
+			"panel.report.recheck": " is re-checked when that text is submitted again — by the agent, not by this page.",
+			"intake.filing": "filing",
+			"intake.waiting": "filed · waiting",
+			"intake.answered": "answered",
+			"intake.alreadyHave": "not filed — already covered",
+			"intake.cited": "cited by a lesson",
+			"intake.submitted": "submitted",
+			"intake.noText": "(text not captured)",
+			"panel.trust.checking": "checking…",
+			"panel.trust.unavailable": "unavailable",
+			"panel.trust.human": "human confirmation",
+			"panel.trust.none": "no level",
+			"panel.trust.used": " · used ",
+			"panel.trust.footnote": "The level is the lesson's own stored evidence. The count is other people's confirmations, not yours: one makes the reuse event appear, the second is what agents read as E4.",
+			"panel.activity.session": "this session: ",
+			"panel.activity.browser": "on this browser: ",
+			"panel.activity.reused": " reused · ",
+			"panel.activity.filed": " filed · ",
+			"panel.activity.conversion": "conversion",
+			"panel.activity.scope": "The browser column survives a reload; the session column is rebuilt from this conversation's transcript and starts again in a new session.",
+			"panel.voice.cue": "The cue is the server's own choice for the last search (",
+			"panel.voice.cueTail": "), not the UI's guess. Browser playback only, and off by default — nothing plays until you turn it on or press play.",
+			"panel.voice.none": "No cue yet: the server names one on the first search of the session.",
+			"panel.voice.play": "Play “",
+			"panel.voice.hook": "The local hook is a different thing: it is installed with `--voice` and mutes with MISAKANET_VOICE=0, plays through this machine's own player, and can also raise a desktop notification. A page cannot read or change it, so this panel does not report its state.",
+			"panel.footnote": "Every number above comes from this conversation's own transcript rows plus one public GET per lesson (/api/helpful). The trust counts are other people's confirmations, not yours. Reloading the window loses the session rows; the browser counters stay. Receipts shown here are what the agent's own calls returned — a pending report is re-checked when the agent asks again, not by this page.",
+			"main.footnote": "The left column opens this page; the session-scoped counters live in the session's right-sidebar MisakaNet tab. The numbers here are what this browser has contributed.",
+			"tool.rawResult": "raw result",
+			"tool.readFailed": "result could not be read",
+			"tool.helpfulTitle": "Sends this lesson's id to misakanet.org as reuse evidence. Sends nothing else.",
+			"tool.notHelpfulTitle": "Sends this lesson's id and the search text, so the gap gets counted.",
+			"tool.helpfulHint": "Helpful sends the lesson id · not-helpful also sends the search text (gap stats)",
+			"tool.helpful": "👍 Helpful",
+			"tool.notHelpful": "👎 Not what I needed",
+			"tool.untitled": "(untitled)",
+			"tool.brand": "MisakaNet:",
+			"settings.rowReadonly": "Shown read-only: this host builds an editable form only for fields a plugin can change without reloading, and this row's settings (endpoint, transport, timeout) apply on the next host start. Edit them in the profile's patch layer — `cordis.patch.yml`, entry id: {row} — next to the {what} the host already has.",
+			"settings.rowNoValues": "No values reported by this host yet; the row runs the bundle patch's defaults.",
+			"settings.noWrites": "This host does not accept writes here (read-only).",
+			"settings.invalidJson": "invalid JSON",
+			"settings.what.form": "form",
+			"settings.what.row": "row",
+			"panel.activity.withLesson": " with a lesson · ",
+			"footer.session": "session: ",
+			"footer.actionHint": "Copy the MisakaNet summary of the session that last used it",
+			"settings.copyPatch": "Copy patch snippet",
+			"settings.copied": "Copied",
+			"settings.copyFailed": "Copy failed",
+		};
+		var zh = {
+			"guide.description": "本会话问过什么、拿回了什么、你报了什么",
+			"panel.asked": "本会话问过什么",
+			"panel.asked.none": "本会话还没有发起过 MisakaNet 检索。",
+			"panel.reports": "你报过的问题",
+			"panel.reports.none": "本会话没有报过任何问题。",
+			"panel.trust": "这些课程的可信度",
+			"panel.trust.none": "还没有命中过课程。",
+			"panel.activity": "你的活动",
+			"panel.voice": "语音",
+			"panel.voice.on": "语音提示：开",
+			"panel.voice.off": "语音提示：关",
+			"overlay.searching": "检索中……",
+			"overlay.empty": "在 /misakanet 后面写清楚出了什么问题，例如 /misakanet pip install 超时",
+			"overlay.none": "还没有课程覆盖这个问题。可以让 agent 报料（misakanet_submit_intake），或直接去 misakanet.org 提交 —— 下一个人就能在这里搜到它。",
+			"overlay.failed": "检索失败：{error} —— 课程库在 misakanet.org；这次只发出了查询本身。",
+			"overlay.footnote": "读取是匿名的。这个浮层只把查询发给 misakanet.org；除此之外，页面只会发出你的投票与报料。",
+			"overlay.close": "关闭",
+			"settings.voice": "在本浏览器播放语音提示",
+			"settings.voice.note": "（与面板上那个开关是同一个）",
+			"settings.density": "MisakaNet 显示多少内容",
+			"settings.density.compact": "精简 —— 标题与领域",
+			"settings.density.full": "完整 —— 另加课程 id 与描述",
+			"settings.endpoint": "MCP 端点",
+			"settings.save": "保存",
+			"settings.saving": "保存中……",
+			"settings.saved": "已保存 —— 下次宿主启动时生效。",
+			"settings.refused": "宿主拒绝了这次写入。",
+			"settings.writeFailed": "写入失败：{error}",
+			"settings.readonly": "本宿主不允许从这里写入该行。",
+			"settings.patchHint": "MCP 端点、传输方式与超时写在 profile 的 cordis.patch.yml 里，条目 id: {row}；本宿主没有为它们提供可写表单。",
+			"settings.local": "上面两个开关只保存在本浏览器，不会上传。",
+			"footer.action": "复制本会话摘要",
+			"footer.copied": "已复制",
+			"footer.nothing": "还没有内容",
+			"footer.failed": "复制失败",
+			"toast.one": "命中 1 篇课程",
+			"toast.many": "命中 {n} 篇课程",
+			"unit.search": "次检索",
+			"unit.searches": "次检索",
+			"unit.lesson": "篇",
+			"unit.lessons": "篇",
+			"unit.vote": "票",
+			"unit.votes": "票",
+			"unit.report": "条报料",
+			"unit.reports": "条报料",
+			"panel.asked.searching": "检索中……",
+			"panel.asked.noMatch": "没有命中任何课程",
+			"panel.asked.top": "· 最佳：",
+			"panel.asked.noQuery": "（没记下查询原文）",
+			"panel.asked.nothingFound": "没有命中",
+			"panel.asked.voteHelpful": "有用",
+			"panel.asked.voteNotHelpful": "没用",
+			"panel.asked.voteNone": "未投票",
+			"panel.asked.voteNoLesson": "无课程",
+			"panel.counters": "本会话 · 计数只存在本浏览器 · 没有账号，除了你的投票与报料，不上传任何东西",
+			"panel.report.title": "MisakaNet 报料",
+			"panel.report.coveredBy": "已被 ",
+			"panel.report.similarity": "（相似度 ",
+			"panel.report.pending": "待处理报料",
+			"panel.report.recheck": " 会在同一段文本被再次提交时复查 —— 由 agent 触发，不是这个页面。",
+			"intake.filing": "提交中",
+			"intake.waiting": "已提交 · 等待中",
+			"intake.answered": "已回答",
+			"intake.alreadyHave": "未提交 —— 已被覆盖",
+			"intake.cited": "已被某篇课程引用",
+			"intake.submitted": "已提交",
+			"intake.noText": "（没抓到原文）",
+			"panel.trust.checking": "核验中……",
+			"panel.trust.unavailable": "不可用",
+			"panel.trust.human": "人工确认",
+			"panel.trust.none": "无等级",
+			"panel.trust.used": " · 已复用 ",
+			"panel.trust.footnote": "等级来自课程自己存的证据；计数是别人的确认，不是你的：前者让复用事件出现，后者才是 agent 读到的 E4。",
+			"panel.activity.session": "本会话：",
+			"panel.activity.browser": "本浏览器：",
+			"panel.activity.reused": " 次复用 · ",
+			"panel.activity.filed": " 条报料 · ",
+			"panel.activity.conversion": "转化",
+			"panel.activity.scope": "浏览器那一列能跨刷新保留；会话那一列由本次对话的转录重建，换一个会话就从零开始。",
+			"panel.voice.cue": "提示音是服务端为上一次检索自己选的（",
+			"panel.voice.cueTail": "），不是界面猜的。只在本浏览器播放，且默认关闭 —— 你不打开或点播放，它不会响。",
+			"panel.voice.none": "还没有提示音：服务端会在本会话第一次检索时给出。",
+			"panel.voice.play": "播放“",
+			"panel.voice.hook": "本地钩子是另一回事：用 --voice 安装，用 MISAKANET_VOICE=0 静音，通过本机自己的播放器发声，还能弹桌面通知。页面读不到也改不了它，所以这个面板不报告它的状态。",
+			"panel.footnote": "上面的数字都来自本次对话自己的转录，外加每篇课程一次公开 GET（/api/helpful）。可信计数是别人的确认，不是你自己的。重载窗口会丢掉会话行，浏览器计数会留下。这里的回执是 agent 自己调用返回的东西 —— 待处理报料会在 agent 再次提问时复查，而不是这个页面。",
+			"main.footnote": "左栏打开的就是这一页；会话级的计数在右栏的 MisakaNet 标签里。这里的数字是本浏览器贡献的部分。",
+			"tool.rawResult": "原始结果",
+			"tool.readFailed": "结果读不出来",
+			"tool.helpfulTitle": "把这篇课程的 id 发给 misakanet.org 作为复用证据，不发别的。",
+			"tool.notHelpfulTitle": "把课程 id 和检索文本一起发出去，好把缺口统计进去。",
+			"tool.helpfulHint": "「有用」只发课程 id ·「没用」还会发检索文本（用于缺口统计）",
+			"tool.helpful": "👍 有用",
+			"tool.notHelpful": "👎 不是我需要的",
+			"tool.untitled": "（无标题）",
+			"tool.brand": "MisakaNet：",
+			"settings.rowReadonly": "只读显示：这个宿主只为「改完不必重载」的字段生成可编辑表单，而本行的设置（端点、传输方式、超时）要在宿主下次启动时生效。请到 profile 的 patch 层修改 —— cordis.patch.yml，条目 id：{row} —— 就在宿主已有的{what}旁边。",
+			"settings.rowNoValues": "宿主还没有报告任何值；这一行用 bundle patch 里的默认值在跑。",
+			"settings.noWrites": "本宿主不允许在这里写入（只读）。",
+			"settings.invalidJson": "JSON 不合法",
+			"settings.what.form": "表单",
+			"settings.what.row": "条目",
+			"panel.activity.withLesson": " 篇命中课程 · ",
+			"footer.session": "会话：",
+			"footer.actionHint": "复制最近一次使用 MisakaNet 的那个会话的摘要",
+			"settings.copyPatch": "复制 patch 片段",
+			"settings.copied": "已复制",
+			"settings.copyFailed": "复制失败",
+		};
+		var T = function (key, params) { return localize(activeLocale(), key, params); };
+		var localeSubscribers = [];
+		var localeFace = null;
+
+		/** Substitute `{name}` placeholders; a missing key falls back to English, then to the key itself. */
+		function localize(locale, key, params) {
+			var dict = locale === "zh" ? zh : en;
+			var text = dict[key] !== undefined ? dict[key] : (en[key] !== undefined ? en[key] : key);
+			if (!params) return text;
+			return text.replace(/\{(\w+)\}/g, function (match, name) {
+				return params[name] === undefined ? match : String(params[name]);
+			});
+		}
+
+		function activeLocale() {
+			try {
+				if (localeFace && typeof localeFace.getLocale === "function") return localeFace.getLocale().active;
+			} catch (error) { /* fall through to the provisional default */ }
+			return "en";
+		}
+
+		function subscribeLocale(listener) {
+			localeSubscribers.push(listener);
+			return function () {
+				var at = localeSubscribers.indexOf(listener);
+				if (at >= 0) localeSubscribers.splice(at, 1);
+			};
+		}
+
+		function notifyLocale() {
+			var list = localeSubscribers.slice();
+			for (var i = 0; i < list.length; i++) list[i]();
+		}
 
 		/** localStorage keys. Both scopes are this browser only — there is no account anywhere here. */
 		var STATS_KEY = "misakanet.panel.stats.v1";
 		var VOICE_KEY = "misakanet.panel.voice.v1";
+		var DENSITY_KEY = "misakanet.panel.density.v1";
+		var prefListeners = [];
+
+		/** Preferences are browser-scope, so their notification is too — not per session. */
+		function subscribePrefs(listener) {
+			prefListeners.push(listener);
+			return function () {
+				var at = prefListeners.indexOf(listener);
+				if (at >= 0) prefListeners.splice(at, 1);
+			};
+		}
+
+		function notifyPrefs() {
+			Promise.resolve().then(function () {
+				var list = prefListeners.slice();
+				for (var i = 0; i < list.length; i++) list[i]();
+			});
+		}
+
+		/** How much a MisakaNet surface shows: `compact` keeps it to a title and its domain. */
+		function density() {
+			try {
+				return window.localStorage.getItem(DENSITY_KEY) === "full" ? "full" : "compact";
+			} catch (error) {
+				return "compact";
+			}
+		}
+
+		function setDensity(value) {
+			try {
+				window.localStorage.setItem(DENSITY_KEY, value === "full" ? "full" : "compact");
+			} catch (error) { /* nothing to remember it with */ }
+			notifyPrefs();
+		}
 
 		/** How many events one session keeps in memory. The panel is a log, not an archive. */
 		var LOG_LIMIT = 200;
@@ -129,8 +427,23 @@ window.__ModuleLoader__.load({
 		 */
 		var sessions = Object.create(null);
 
+		/**
+		 * The session that moved last.
+		 *
+		 * The panel and the verdict row are session-scoped and receive a `sessionId`; the frame-wide seats
+		 * (`shell.overlay`, `sidebar.footer.action`) receive none — "each action receives only the column
+		 * state" is the footer's own wording. So the store remembers which session was touched most recently
+		 * and those two surfaces speak about it.
+		 */
+		var lastSessionId = null;
+
+		function touchSession(sessionId) {
+			if (sessionId) lastSessionId = sessionId;
+		}
+
 		function sessionLog(sessionId) {
 			if (!sessionId) return null;
+			touchSession(sessionId);
 			if (!sessions[sessionId]) {
 				sessions[sessionId] = {
 					sessionId: sessionId,
@@ -199,6 +512,7 @@ window.__ModuleLoader__.load({
 			} catch (error) {
 				/* nothing to remember it with; the toggle still reports what it did */
 			}
+			notifyPrefs();
 		}
 
 		/**
@@ -247,6 +561,76 @@ window.__ModuleLoader__.load({
 		 */
 		var listeners = Object.create(null);
 
+		// The slash command's result overlay. It lives in the same per-session store as the counters, so
+		// switching sessions switches the overlay with everything else, and one `notify` redraws both.
+var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
+
+		var SEARCH_ENDPOINT = "https://misakanet.org/api/lessons";
+		var OVERLAY_LIMIT = 5;
+		var OVERLAY_TIMEOUT_MS = 8000;
+
+		function isJson(text) {
+			try { JSON.parse(text); return true; } catch (error) { return false; }
+		}
+
+		function overlayOf(sessionId) {
+			var log = sessions[sessionId];
+			if (!log) {
+				log = sessions[sessionId] = { searches: [], intakes: [], votes: [], lessons: {} };
+			}
+			if (!log.overlay) {
+				log.overlay = { open: false, query: "", status: "idle", results: [], error: null };
+			}
+			return log.overlay;
+		}
+
+		function setOverlay(sessionId, patch) {
+			touchSession(sessionId);
+			notifyShell();
+			var state = overlayOf(sessionId);
+			for (var key in patch) {
+				if (Object.prototype.hasOwnProperty.call(patch, key)) state[key] = patch[key];
+			}
+			notify(sessionId);
+		}
+
+		/**
+		 * Search from the composer, without the agent in the loop.
+		 *
+		 * `GET /api/lessons?q=` is public, CORS-open (measured 2026-10-01: `access-control-allow-origin: *`)
+		 * and returns `{query, results:[{id, title, domain, path, tags, description, rank}]}` — the same rows
+		 * the MCP tool returns, so the overlay needs no new backend. The request carries the query and
+		 * nothing else; the comment says so where a reader will look for it.
+		 */
+		function runOverlaySearch(sessionId, query) {
+			query = String(query || "").trim();
+			if (!query) {
+				setOverlay(sessionId, { open: true, query: "", status: "idle", results: [], error: null });
+				return;
+			}
+			setOverlay(sessionId, { open: true, query: query, status: "loading", results: [], error: null });
+			var timedOut = false;
+			var timer = setTimeout(function () { timedOut = true; }, OVERLAY_TIMEOUT_MS);
+			var url = SEARCH_ENDPOINT + "?q=" + encodeURIComponent(query) + "&limit=" + OVERLAY_LIMIT;
+			fetch(url, { headers: { accept: "application/json" } })
+				.then(function (response) {
+					clearTimeout(timer);
+					if (timedOut) return null;
+					if (!response.ok) throw new Error("HTTP " + response.status);
+					return response.json();
+				})
+				.then(function (data) {
+					if (timedOut || data === null) return;
+					setOverlay(sessionId, { status: "done", results: (data && data.results) || [], error: null });
+				})
+				.catch(function (error) {
+					clearTimeout(timer);
+					if (timedOut) return;
+					setOverlay(sessionId, { status: "error", results: [],
+						error: (error && error.message) || String(error) });
+				});
+		}
+
 		function subscribe(sessionId, listener) {
 			if (!sessionId) return function () {};
 			if (!listeners[sessionId]) listeners[sessionId] = [];
@@ -258,6 +642,31 @@ window.__ModuleLoader__.load({
 			};
 		}
 
+		var shellListeners = [];
+
+		/**
+		 * The frame-wide seats (`shell.overlay`, `sidebar.footer.action`) receive no `sessionId`, and at mount
+		 * there is no session to subscribe to yet — an effect that returned early on a null id would subscribe
+		 * to nothing and never repaint. They subscribe to this instead, and the store announces here whenever
+		 * session state moves.
+		 */
+		function subscribeShell(listener) {
+			shellListeners.push(listener);
+			return function () {
+				var at = shellListeners.indexOf(listener);
+				if (at >= 0) shellListeners.splice(at, 1);
+			};
+		}
+
+		function notifyShell() {
+			Promise.resolve().then(function () {
+				var list = shellListeners.slice();
+				for (var i = 0; i < list.length; i++) {
+					try { list[i](); } catch (error) { /* one listener's failure is not the others' problem */ }
+				}
+			});
+		}
+
 		function notify(sessionId) {
 			if (!sessionId) return;
 			Promise.resolve().then(function () {
@@ -326,6 +735,7 @@ window.__ModuleLoader__.load({
 				log.lessons[entry.lessonId].last = entry.at;
 			}
 			return entry;
+			notifyShell();
 		}
 
 		/** Record a vote and retire the sighting it answered. */
@@ -343,6 +753,7 @@ window.__ModuleLoader__.load({
 			}
 			bumpStat("votes");
 			if (log) notify(log.sessionId);
+			notifyShell();
 		}
 
 		/**
@@ -355,7 +766,7 @@ window.__ModuleLoader__.load({
 		function intakeState(payload) {
 			if (!payload || typeof payload !== "object") return "unknown";
 			if (payload.converted) return "converted";
-			if (payload.answered) return "answered";
+			if (payload.answered) return T("intake.answered");
 			if (payload.already_have) return "already_have";
 			if (payload.pending || payload.duplicate || payload.submitted) return "pending";
 			return "unknown";
@@ -385,7 +796,7 @@ window.__ModuleLoader__.load({
 				callId: String(callId || ""),
 				at: Date.now(),
 				text: String(text || ""),
-				state: phase === "result" ? intakeState(payload) : "filing",
+				state: phase === "result" ? intakeState(payload) : T("intake.filing"),
 				receipt: String((payload && (payload.receipt || payload.note)) || ""),
 				issue: String((payload && (payload.intake_id || payload.previous_issue)) || ""),
 				answer: String((payload && payload.answer) || ""),
@@ -395,6 +806,7 @@ window.__ModuleLoader__.load({
 			if (entry.state === "converted") bumpStat("reportsConverted");
 			notify(log.sessionId);
 			return entry;
+			notifyShell();
 		}
 
 		/** Concatenate the text blocks of a result node; "" when there are none. */
@@ -519,15 +931,15 @@ window.__ModuleLoader__.load({
 			var head = [h("strong", { key: "brand" }, "MisakaNet")];
 
 			if (phase === "preparing") {
-				head.push(h("span", { key: "state", style: DIM }, " searching…"));
+				head.push(h("span", { key: "state", style: DIM }, " " + T("panel.asked.searching")));
 			} else if (phase === "start") {
-				head.push(h("span", { key: "state" }, " " + (query || "searching…")));
+				head.push(h("span", { key: "state" }, " " + (query || T("panel.asked.searching"))));
 			} else if (payload && payload.no_match) {
-				head.push(h("span", { key: "state" }, " no lesson matched"));
+				head.push(h("span", { key: "state" }, " " + T("panel.asked.noMatch")));
 			} else if (results.length) {
 				head.push(h("span", { key: "state" }, " " + results.length + (results.length === 1 ? " lesson" : " lessons")));
 				head.push(h("span", { key: "top", style: DIM }, " · top: "));
-				head.push(h("span", { key: "title" }, top.title || top.id || "(untitled)"));
+				head.push(h("span", { key: "title" }, top.title || top.id || T("tool.untitled")));
 				// Only fields the DEFAULT payload actually carries. `detail: "compact"` is
 				// {id, title, problem, freshness, evidence_level}; `domain` arrives only at
 				// `detail: "summary"` and `path` only at `"full"`. The first version of this row promised
@@ -539,7 +951,7 @@ window.__ModuleLoader__.load({
 				var facts = [top.evidence_level, top.freshness].filter(Boolean).join(" · ");
 				if (facts) head.push(h("span", { key: "meta", style: DIM }, " (" + facts + ")"));
 			} else if (phase === "result") {
-				head.push(h("span", { key: "state", style: DIM }, " result could not be read"));
+				head.push(h("span", { key: "state", style: DIM }, " " + T("tool.readFailed")));
 			}
 
 			var body = [h("div", { key: "body", style: BOX }, h("div", null, head))];
@@ -547,7 +959,7 @@ window.__ModuleLoader__.load({
 			if (raw) {
 				body.push(
 					h("details", { key: "raw" },
-						h("summary", { style: Object.assign({}, DIM, { cursor: "pointer", fontSize: "12px" }) }, "raw result"),
+						h("summary", { style: Object.assign({}, DIM, { cursor: "pointer", fontSize: "12px" }) }, T("tool.rawResult")),
 						h("pre", { style: { fontSize: "11px", overflowX: "auto", whiteSpace: "pre-wrap" } }, raw))
 				);
 			}
@@ -618,24 +1030,24 @@ window.__ModuleLoader__.load({
 			return h("span", {
 				style: { fontSize: "12px", display: "inline-flex", flexWrap: "wrap", alignItems: "center", rowGap: "2px" },
 			},
-				h("span", { style: Object.assign({}, DIM, { marginRight: "6px" }) }, "MisakaNet:"),
+				h("span", { style: Object.assign({}, DIM, { marginRight: "6px" }) }, T("tool.brand")),
 				h("button", {
 					type: "button",
 					style: BUTTON,
-					title: "Sends this lesson's id to misakanet.org as reuse evidence. Sends nothing else.",
+					title: T("tool.helpfulTitle"),
 					onClick: function () { send("helpful"); },
-				}, "👍 Helpful"),
+				}, T("tool.helpful")),
 				h("button", {
 					type: "button",
 					style: BUTTON,
-					title: "Sends this lesson's id and the search text, so the gap gets counted.",
+					title: T("tool.notHelpfulTitle"),
 					onClick: function () { send("irrelevant"); },
-				}, "👎 Not what I needed"),
+				}, T("tool.notHelpful")),
 				// Words, not the emoji, carry this line: an environment without an emoji font renders the
 				// buttons as boxes, and a disclosure that turns into "□ sends the lesson id" is worse than
 				// none. The button labels survive the same way.
 				h("span", { style: Object.assign({}, DIM, { flexBasis: "100%" }) },
-					"Helpful sends the lesson id · not-helpful also sends the search text (gap stats)")
+					T("tool.helpfulHint"))
 			);
 		}
 
@@ -662,10 +1074,10 @@ window.__ModuleLoader__.load({
 				answered: "answered",
 				already_have: "not filed — the corpus already covers this",
 				converted: "your report is cited by a lesson",
-				unknown: "submitted",
+				unknown: T("intake.submitted"),
 			};
 			var head = [
-				h("strong", { key: "brand" }, "MisakaNet report"),
+				h("strong", { key: "brand" }, T("panel.report.title")),
 				h("span", { key: "state", style: DIM }, " " + (labels[state] || state)),
 			];
 			var body = [h("div", { key: "head" }, head)];
@@ -678,7 +1090,7 @@ window.__ModuleLoader__.load({
 			}
 			if (payload && payload.lesson && payload.lesson.id) {
 				body.push(h("div", { key: "lesson", style: DIM },
-					"covered by " + payload.lesson.id + (payload.lesson.similarity ? " (similarity " + payload.lesson.similarity + ")" : "")));
+					T("panel.report.coveredBy") + payload.lesson.id + (payload.lesson.similarity ? T("panel.report.similarity") + payload.lesson.similarity + ")" : "")));
 			}
 			return h("div", { style: BOX }, body);
 		}
@@ -708,6 +1120,8 @@ window.__ModuleLoader__.load({
 					setRevision(function (n) { return n + 1; });
 				});
 			}, [sessionId]);
+			react.useEffect(function () { return subscribePrefs(function () { setRevision(function (n) { return n + 1; }); }); }, []);
+			react.useEffect(function () { return subscribeLocale(function () { setRevision(function (n) { return n + 1; }); }); }, []);
 
 			var log = sessionId ? sessions[sessionId] : null;
 			var searches = log ? log.searches : [];
@@ -762,25 +1176,25 @@ window.__ModuleLoader__.load({
 			rows.push(h("div", { key: "title", style: { fontSize: "15px", fontWeight: 600, display: "flex", alignItems: "center", gap: "6px" } },
 				MisakanetGlyph({ size: 18 }), h("span", null, "MisakaNet")));
 			rows.push(h("div", { key: "scope", style: DIM },
-				"this session · counters local to this browser · no account, nothing uploaded but your votes and reports"));
+				T("panel.counters")));
 
 			rows.push(h("div", { key: "strip", style: Object.assign({}, BOX, { marginTop: "8px" }) },
-				count(searches.length, "search", "searches") + " · " + withLesson + " with a lesson · " +
-				noMatch + " nothing found · " + count(lessons.length, "lesson") + " surfaced · " +
-				count(votes.length, "vote") + " (" + helpful + " helpful) · " +
+				count(searches.length, T("unit.search"), T("unit.searches")) + " · " + withLesson + " with a lesson · " +
+				noMatch + " " + T("panel.asked.nothingFound") + " · " + count(lessons.length, "lesson") + " surfaced · " +
+				count(votes.length, T("unit.vote")) + " (" + helpful + " helpful) · " +
 				count(intakes.length, "report") + " (" + converted + " became a lesson)"));
 
 			// ① what this session asked
-			rows.push(h("div", { key: "s1", style: { marginTop: "12px", fontWeight: 600 } }, "What this session asked"));
+			rows.push(h("div", { key: "s1", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.asked")));
 			if (!searches.length) {
-				rows.push(h("div", { key: "s1e", style: DIM }, "No MisakaNet search has run in this session yet."));
+				rows.push(h("div", { key: "s1e", style: DIM }, T("panel.asked.none")));
 			} else {
 				var searchRows = searches.slice().reverse().slice(0, 20).map(function (entry) {
 					var vote = entry.voted ? (entry.voteKind === "helpful" ? "Helpful" : "not helpful") : (entry.lessonId ? "not voted" : "no lesson");
 					return h("div", { key: "q" + entry.callId + entry.at, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
 						h("span", { style: DIM }, clockOf(entry.at) + "  "),
-						h("span", {}, entry.query || "(no query text)"),
-						h("span", { style: DIM }, "  " + (entry.noMatch ? "nothing found" : count(entry.hits, "lesson"))),
+						h("span", {}, entry.query || T("panel.asked.noQuery")),
+						h("span", { style: DIM }, "  " + (entry.noMatch ? T("panel.asked.nothingFound") : count(entry.hits, T("unit.lesson")))),
 						entry.title ? h("span", { style: DIM }, "  · top: " + entry.title + (entry.evidence ? " (" + entry.evidence + ")" : "")) : null,
 						h("span", { style: DIM }, "  · " + vote));
 				});
@@ -788,7 +1202,7 @@ window.__ModuleLoader__.load({
 			}
 
 			// ② reports filed
-			rows.push(h("div", { key: "s2", style: { marginTop: "12px", fontWeight: 600 } }, "Reports you filed"));
+			rows.push(h("div", { key: "s2", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.reports")));
 			var openReports = intakes.filter(function (entry) {
 				return entry.state !== "converted" && entry.state !== "answered" && entry.state !== "already_have";
 			});
@@ -799,62 +1213,61 @@ window.__ModuleLoader__.load({
 				// is not allowed to do that, so the panel says who can re-check instead of offering it —
 				// and only for the reports that are actually still open.
 				rows.push(h("div", { key: "s2h", style: DIM },
-					count(openReports.length, "pending report") + " is re-checked when that text is submitted again — by the agent, not by this page."));
+					count(openReports.length, T("panel.report.pending")) + T("panel.report.recheck")));
 			}
 			if (!intakes.length) {
-				rows.push(h("div", { key: "s2e", style: DIM }, "Nothing filed from this session."));
+				rows.push(h("div", { key: "s2e", style: DIM }, T("panel.reports.none")));
 			} else {
 				rows.push(h("div", { key: "s2r" }, intakes.slice().reverse().map(function (entry) {
 					var labels = {
-						filing: "filing", pending: "filed · waiting", answered: "answered",
-						already_have: "not filed — already covered", converted: "cited by a lesson", unknown: "submitted",
+						filing: "filing", pending: T("intake.waiting"), answered: "answered",
+						already_have: T("intake.alreadyHave"), converted: T("intake.cited"), unknown: "submitted",
 					};
 					var issue = String(entry.issue || "").replace(/^issue-/, "#").replace(/^.*\/issues\//, "#");
 					return h("div", { key: "r" + entry.callId + entry.at, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
 						h("span", { style: DIM }, clockOf(entry.at) + "  "),
 						issue ? h("span", { style: DIM }, issue + "  ") : null,
 						h("span", { style: DIM }, (labels[entry.state] || entry.state) + "  "),
-						h("span", {}, entry.text ? (entry.text.length > 90 ? entry.text.slice(0, 90) + "…" : entry.text) : "(text not captured)"),
+						h("span", {}, entry.text ? (entry.text.length > 90 ? entry.text.slice(0, 90) + "…" : entry.text) : T("intake.noText")),
 						entry.receipt ? h("div", { style: DIM }, entry.receipt) : null,
 						entry.answer ? h("div", {}, entry.answer) : null);
 				})));
 			}
 
 			// ③ how much these lessons are trusted
-			rows.push(h("div", { key: "s3", style: { marginTop: "12px", fontWeight: 600 } }, "How much these lessons are trusted"));
+			rows.push(h("div", { key: "s3", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.trust")));
 			if (!lessons.length) {
-				rows.push(h("div", { key: "s3e", style: DIM }, "No lesson surfaced yet."));
+				rows.push(h("div", { key: "s3e", style: DIM }, T("panel.trust.none")));
 			} else {
 				// The rule once, not per row: it is the same sentence for every lesson, and repeating it
 				// four times buries the numbers it is there to explain.
 				rows.push(h("div", { key: "s3rule", style: DIM },
-					"The level is the lesson's own stored evidence. The count is other people's confirmations, not yours: " +
-					"one makes the reuse event appear, the second is what agents read as E4."));
+					T("panel.trust.footnote")));
 				rows.push(h("div", { key: "s3r" }, lessons.map(function (lesson) {
 					var confirmations = trust[lesson.lessonId];
-					var counted = confirmations === undefined ? "checking…"
-						: (confirmations === null ? "unavailable"
-							: count(confirmations, "human confirmation") + (confirmations >= 2 ? " → E4" : ""));
+					var counted = confirmations === undefined ? T("panel.trust.checking")
+						: (confirmations === null ? T("panel.trust.unavailable")
+							: count(confirmations, T("panel.trust.human")) + (confirmations >= 2 ? " → E4" : ""));
 					return h("div", { key: "l" + lesson.lessonId, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
 						h("span", {}, lesson.title || lesson.lessonId),
-						h("span", { style: DIM }, "  " + (lesson.evidence || "no level") + " · " + counted +
-							" · used " + lesson.count + "× · " + timeRange(lesson)));
+						h("span", { style: DIM }, "  " + (lesson.evidence || T("panel.trust.none")) + " · " + counted +
+							T("panel.trust.used") + lesson.count + "× · " + timeRange(lesson)));
 				})));
 			}
 
 			// ④ your activity, two scopes
-			rows.push(h("div", { key: "s4", style: { marginTop: "12px", fontWeight: 600 } }, "Your activity"));
+			rows.push(h("div", { key: "s4", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.activity")));
 			rows.push(h("div", { key: "s4r", style: BOX },
-				h("div", {}, "this session: " + count(searches.length, "search", "searches") + " · " + count(lessons.length, "lesson") +
-					" reused · " + count(votes.length, "vote") + " · " + count(intakes.length, "report") + " filed · " +
-					count(converted, "conversion")),
-				h("div", {}, "on this browser: " + count(stats.searches || 0, "search", "searches") + " · " +
+				h("div", {}, T("panel.activity.session") + count(searches.length, "search", "searches") + " · " + count(lessons.length, "lesson") +
+					T("panel.activity.reused") + count(votes.length, "vote") + " · " + count(intakes.length, "report") + T("panel.activity.filed") +
+					count(converted, T("panel.activity.conversion"))),
+				h("div", {}, T("panel.activity.browser") + count(stats.searches || 0, T("unit.search"), T("unit.searches")) + " · " +
 					count(stats.lessonsReused || 0, "lesson") + " reused · " + count(stats.votes || 0, "vote") + " · " +
 					count(stats.reportsFiled || 0, "report") + " filed · " + count(stats.reportsConverted || 0, "conversion")),
-				h("div", { style: DIM }, "The browser column survives a reload; the session column is rebuilt from this conversation's transcript and starts again in a new session.")));
+				h("div", { style: DIM }, T("panel.activity.scope"))));
 
 			// ⑤ voice
-			rows.push(h("div", { key: "s5", style: { marginTop: "12px", fontWeight: 600 } }, "Voice"));
+			rows.push(h("div", { key: "s5", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.voice")));
 			rows.push(h("div", { key: "s5r", style: BOX },
 				h("button", {
 					type: "button",
@@ -864,22 +1277,19 @@ window.__ModuleLoader__.load({
 						setVoiceEnabled(next);
 						setVoice(next);
 					},
-				}, voice ? "Voice cues: on" : "Voice cues: off"),
+				}, T(voice ? "panel.voice.on" : "panel.voice.off")),
 				lastCue && h("button", {
 					type: "button",
 					style: BUTTON,
 					onClick: function () { playCue(lastCue); },
-				}, "Play “" + lastCue + "”"),
+				}, T("panel.voice.play") + lastCue + "”"),
 				h("div", { style: DIM }, lastCue
-					? "The cue is the server's own choice for the last search (" + lastCue + "), not the UI's guess. Browser playback only, and off by default — nothing plays until you turn it on or press play."
-					: "No cue yet: the server names one on the first search of the session."),
-				h("div", { style: DIM }, "The local hook is a different thing: it is installed with `--voice` and mutes with MISAKANET_VOICE=0, plays through this machine's own player, and can also raise a desktop notification. A page cannot read or change it, so this panel does not report its state.")));
+					? T("panel.voice.cue") + lastCue + T("panel.voice.cueTail")
+					: T("panel.voice.none")),
+				h("div", { style: DIM }, T("panel.voice.hook"))));
 
 			rows.push(h("div", { key: "foot", style: Object.assign({}, DIM, { marginTop: "12px" }) },
-				"Every number above comes from this conversation's own transcript rows plus one public GET per lesson " +
-				"(/api/helpful). The trust counts are other people's confirmations, not yours. Reloading the window loses " +
-				"the session rows; the browser counters stay. Receipts shown here are what the agent's own calls returned — " +
-				"a pending report is re-checked when the agent asks again, not by this page."));
+				T("panel.footnote")));
 
 			return h("div", { style: { fontSize: "12px", lineHeight: "1.7", padding: "4px 2px" } }, rows);
 		}
@@ -912,6 +1322,515 @@ window.__ModuleLoader__.load({
 			return h(react.Fragment, null, MisakanetGlyph({ size: 16 }), h("span", { style: { paddingLeft: "4px" } }, "MisakaNet"));
 		}
 
+		/** One result row: the title, where it came from, and a link to read it. */
+		function MisakanetOverlayRow(result) {
+			var path = String(result && result.id ? result.id : "");
+			var href = path ? "https://misakanet.org/lessons/" + path : "https://misakanet.org/";
+			return h("a", {
+				href: href, target: "_blank", rel: "noreferrer",
+				style: { display: "block", padding: "7px 8px", borderRadius: "8px", textDecoration: "none",
+					color: "inherit", border: "1px solid transparent" },
+			}, h("div", { style: { display: "flex", alignItems: "baseline", gap: "6px" } },
+				h("span", { style: { fontWeight: 600 } }, String(result && result.title ? result.title : "(untitled)")),
+				result && result.domain ? h("span", { style: { opacity: 0.6, fontSize: "11px" } }, String(result.domain)) : null),
+				density() === "full"
+					? h("div", { style: { opacity: 0.65, fontSize: "11px", marginTop: "2px" } }, path) : null,
+				density() === "full" && result && result.description
+					? h("div", { style: { opacity: 0.6, fontSize: "11px", marginTop: "2px" } },
+						String(result.description).replace(/\s+/g, " ").slice(0, 160))
+					: null);
+		}
+
+
+		/**
+		 * The row's configuration as a `cordis.patch.yml` entry.
+		 *
+		 * Both cards that show this row cannot write it: the plugin page builds forms only from `volatile()`
+		 * fields, and a settings row's namespace is not always exposed. What a reader needs at that point is the
+		 * text they can paste into their own patch layer, so this produces exactly that — the same document the
+		 * host's native editor points at.
+		 */
+		function patchSnippet(values) {
+			var lines = ["- id: " + ROW_ID, "  disabled: false", "  config:"];
+			var keys = Object.keys(values || {});
+			for (var i = 0; i < keys.length; i++) {
+				var name = keys[i];
+				var value = values[name];
+				if (value !== null && typeof value === "object") {
+					lines.push("    " + name + ":");
+					var inner = Object.keys(value);
+					for (var j = 0; j < inner.length; j++) {
+						lines.push("      " + inner[j] + ": " + yamlScalar(value[inner[j]]));
+					}
+				} else {
+					lines.push("    " + name + ": " + yamlScalar(value));
+				}
+			}
+			return lines.join("\n") + "\n";
+		}
+
+		function yamlScalar(value) {
+			if (typeof value === "boolean" || typeof value === "number") return String(value);
+			if (value === null || value === undefined) return '""';
+			var text = String(value);
+			return /^[A-Za-z0-9._\/-]+$/.test(text) ? text : JSON.stringify(text);
+		}
+
+		/** Copy text and report it in the button's own label; never throws at the reader. */
+		function copyText(text, onDone) {
+			try {
+				window.navigator.clipboard.writeText(text).then(function () { onDone(T("settings.copied")); },
+					function () { onDone(T("settings.copyFailed")); });
+			} catch (error) {
+				onDone(T("settings.copyFailed"));
+			}
+		}
+
+		/**
+		 * The frame-wide toast (`shell.overlay`): the layer is click-through, so an occupant opts back into
+		 * pointer events itself, and this card does that on its own root.
+		 *
+		 * It announces the one thing worth interrupting for — a `/misakanet` search in this session came back
+		 * with lessons — and then gets out of the way: once per query, dismissible, and gone after a few
+		 * seconds. The title links to the lesson so the click lands somewhere useful.
+		 */
+		var TOAST_MS = 12000;
+
+		function MisakanetShellToast() {
+			var revisionState = react.useState(0);
+			var bump = function () { setRevision(function (n) { return n + 1; }); };
+			var setRevision = revisionState[1];
+			var hiddenState = react.useState(null);
+			var hidden = hiddenState[0];
+			var setHidden = hiddenState[1];
+
+			react.useEffect(function () { return subscribeShell(bump); }, []);
+			react.useEffect(function () { return subscribePrefs(bump); }, []);
+			react.useEffect(function () { return subscribeLocale(bump); }, []);
+
+			var log = lastSessionId ? sessions[lastSessionId] : null;
+			// The overlay's own state is nested (`log.overlay`), unlike the counters beside it.
+			var overlay = log && log.overlay ? log.overlay : null;
+			var query = overlay && overlay.status === "done" && overlay.results && overlay.results.length
+				? overlay.query : null;
+			react.useEffect(function () {
+				if (!query) return undefined;
+				var timer = setTimeout(function () { setHidden(query); }, TOAST_MS);
+				return function () { clearTimeout(timer); };
+			}, [query]);
+
+			if (!query || hidden === query) return null;
+			var top = overlay.results[0] || {};
+			var lessonId = top.id ? String(top.id) : "";
+			return h("div", {
+				style: { position: "fixed", right: "16px", bottom: "16px", zIndex: 40, maxWidth: "320px",
+					pointerEvents: "auto", background: "Canvas", color: "CanvasText", border: "1px solid rgba(127,127,127,.35)",
+					borderRadius: "8px", boxShadow: "0 6px 20px rgba(0,0,0,.22)", padding: "10px 12px", fontSize: "13px",
+					display: "grid", gap: "6px" },
+			}, h("div", { style: { display: "flex", alignItems: "center", gap: "6px" } },
+				MisakanetGlyph({ size: 16 }),
+				h("span", { style: { fontWeight: 600 } }, "MisakaNet"),
+				h("span", { style: { opacity: 0.6, fontSize: "11px" } },
+					overlay.results.length === 1 ? T("toast.one") : T("toast.many", { n: overlay.results.length })),
+				h("span", { style: { flex: 1 } }),
+				h("button", { type: "button", title: T("overlay.close"), "aria-label": T("overlay.close"),
+					style: { background: "transparent", border: 0, color: "inherit", cursor: "pointer", opacity: 0.7 },
+					onClick: function () { setHidden(query); } }, "×")),
+				lessonId
+					? h("a", { href: "https://misakanet.org/lessons/" + encodeURIComponent(lessonId),
+						target: "_blank", rel: "noreferrer", style: { color: "inherit", fontWeight: 600 } },
+						String(top.title || lessonId))
+					: h("span", null, String(top.title || "")),
+				top.domain ? h("span", { style: { opacity: 0.65, fontSize: "11px" } }, String(top.domain)) : null);
+		}
+
+		/**
+		 * The sidebar footer action (`sidebar.footer.action`): copy this session's MisakaNet activity as a
+		 * summary, which is exactly what a bug report or a PR body wants to quote.
+		 *
+		 * It receives only the column state, so it reads the same most-recently-touched session the toast does,
+		 * and reports what it did in its own label rather than throwing a dialog at the reader.
+		 */
+		function MisakanetFooterAction() {
+			var revisionState = react.useState(0);
+			var bump = function () { setRevision(function (n) { return n + 1; }); };
+			var setRevision = revisionState[1];
+			var noteState = react.useState(null);
+			var note = noteState[0];
+			var setNote = noteState[1];
+
+			react.useEffect(function () { return subscribeShell(bump); }, []);
+			react.useEffect(function () { return subscribePrefs(bump); }, []);
+			react.useEffect(function () { return subscribeLocale(bump); }, []);
+
+			function summary() {
+				var log = lastSessionId ? sessions[lastSessionId] : null;
+				if (!log) return "";
+				var searched = log.searches ? log.searches.length : 0;
+				var withLesson = log.searches ? log.searches.filter(function (s) { return s.lessonId; }).length : 0;
+				var ids = log.searches ? log.searches.map(function (s) { return s.lessonId; }).filter(Boolean) : [];
+				var helpful = log.votes ? log.votes.filter(function (v) { return v && v.helpful; }).length : 0;
+				var overlay = log.overlay || {};
+				var lines = [
+					"MisakaNet — this session",
+					T("footer.session") + String(lastSessionId).replace(/^session-/, "").slice(0, 8),
+					"tool searches: " + searched + " (" + withLesson + " with a lesson)",
+					"lessons: " + (ids.length ? ids.join(", ") : "—"),
+					"votes: " + (log.votes ? log.votes.length : 0) + " (helpful " + helpful + ")",
+					"reports filed: " + (log.intakes ? log.intakes.length : 0),
+				];
+				// The `/misakanet` command never goes through the MCP tools, so its search is its own line
+				// rather than being folded into a count that would then describe something else.
+				if (overlay.query) {
+					lines.push("composer search: '" + overlay.query + "' → " +
+						(overlay.status === "done" ? (overlay.results || []).length + " results" : overlay.status));
+				}
+				return lines.join("\n");
+			}
+
+			function copy() {
+				var text = summary();
+				if (!text) { setNote(T("footer.nothing")); return; }
+				try {
+					window.navigator.clipboard.writeText(text).then(function () { setNote(T("footer.copied")); },
+						function () { setNote(T("footer.failed")); });
+				} catch (error) {
+					setNote(T("footer.failed"));
+				}
+			}
+
+			var label = note || T("footer.action");
+			return h("button", { type: "button", title: T("footer.actionHint"), "aria-label": label, onClick: copy,
+				style: { display: "inline-flex", alignItems: "center", gap: "6px", background: "transparent",
+					border: 0, color: "inherit", cursor: "pointer", fontSize: "12px", padding: "4px 6px" },
+			}, MisakanetGlyph({ size: 16 }), h("span", null, label));
+		}
+
+		/**
+		 * The settings row (`settings.general.item`, root scope, **no props from the owner**).
+		 *
+		 * The host's contract for this seat is explicit: "the section column only stacks rows, so a row draws
+		 * its own internals, including its label … copy, current value, and the write path are all yours".
+		 * So this renders its own header and its controls.
+		 *
+		 * Two of the three are browser preferences this page owns (voice cues, how much the surfaces show).
+		 * The third is the MCP endpoint, and it is the interesting one: the plugin page could not offer a form
+		 * for it, because the host builds those only from `volatile()` fields — but a settings row may hold the
+		 * namespace's `ConfigForm` itself and write through it. When the host exposes no such namespace, the row
+		 * says where the value lives instead of pretending to edit it.
+		 */
+		function MisakanetSettingsRow(props) {
+			var face = (props && props.hooks) || {};
+			var hostForm = face.hostForm;
+			var revisionState = react.useState(0);
+			var setRevision = revisionState[1];
+			var bump = function () { setRevision(function (n) { return n + 1; }); };
+			var urlState = react.useState(null);
+			var url = urlState[0];
+			var setUrl = urlState[1];
+			var statusState = react.useState(null);
+			var status = statusState[0];
+			var setStatus = statusState[1];
+
+			react.useEffect(function () { return subscribePrefs(bump); }, []);
+			react.useEffect(function () { return subscribeLocale(bump); }, []);
+			react.useEffect(function () {
+				if (!hostForm || typeof hostForm.subscribe !== "function") return undefined;
+				return hostForm.subscribe(bump);
+			}, [hostForm]);
+			var snapshot = hostForm && typeof hostForm.getSnapshot === "function" ? hostForm.getSnapshot() : null;
+			react.useEffect(function () {
+				setUrl(snapshot && snapshot.value && typeof snapshot.value.url === "string" ? snapshot.value.url : null);
+			}, [snapshot && snapshot.revision, snapshot && snapshot.status]);
+
+			var writable = Boolean(snapshot && snapshot.status === "ready" && snapshot.writable !== false);
+
+			function saveUrl() {
+				if (!hostForm || !snapshot || typeof hostForm.set !== "function") return;
+				setStatus(T("settings.saving"));
+				hostForm.set("url", String(url || "")).then(function (accepted) {
+					setStatus(accepted ? T("settings.saved") : T("settings.refused"));
+				}, function (error) {
+					setStatus(T("settings.writeFailed", { error: (error && error.message) || String(error) }));
+				});
+			}
+
+			return h("div", { style: { display: "grid", gap: "8px", fontSize: "13px", padding: "2px 0" } },
+				h("div", { style: { display: "flex", alignItems: "center", gap: "6px" } },
+					MisakanetGlyph({ size: 16 }), h("span", { style: { fontWeight: 600 } }, "MisakaNet")),
+				h("label", { style: { display: "flex", alignItems: "center", gap: "8px" } },
+					h("input", { type: "checkbox", checked: voiceEnabled(),
+						onChange: function (event) { setVoiceEnabled(event.target.checked); } }),
+					h("span", null, T("settings.voice")),
+					h("span", { style: { opacity: 0.6, fontSize: "11px" } }, T("settings.voice.note"))),
+				h("label", { style: { display: "flex", alignItems: "center", gap: "8px" } },
+					h("span", null, T("settings.density")),
+					h("select", { value: density(), onChange: function (event) { setDensity(event.target.value); } },
+						h("option", { value: "compact" }, T("settings.density.compact")),
+						h("option", { value: "full" }, T("settings.density.full")))),
+				snapshot && snapshot.status === "ready"
+					? h("div", { style: { display: "grid", gap: "6px" } },
+						h("label", { style: { display: "flex", alignItems: "center", gap: "8px" } },
+							h("span", { style: { width: "9rem", opacity: 0.8 } }, T("settings.endpoint")),
+							h("input", { type: "text", value: url === null ? "" : url, disabled: !writable,
+								style: { width: "22rem", maxWidth: "100%" },
+								onChange: function (event) { setUrl(event.target.value); setStatus(null); } }),
+							h("button", { type: "button", disabled: !writable, onClick: saveUrl,
+								style: { cursor: writable ? "pointer" : "not-allowed" } }, T("settings.save")),
+							status ? h("span", { style: { opacity: 0.75, fontSize: "12px" } }, status) : null),
+						writable ? null : h("span", { style: { opacity: 0.6, fontSize: "11px" } },
+							T("settings.readonly")))
+					: h("span", { style: { display: "inline-flex", alignItems: "center", gap: "8px" } },
+						h("span", { style: { opacity: 0.6, fontSize: "11px" } },
+							T("settings.patchHint", { row: ROW_ID })),
+						h("button", { type: "button", style: { cursor: "pointer" },
+							onClick: function () {
+								// this row has a `snapshot`, not the card's `resolved`: naming the wrong one threw
+								// `resolved is not defined` in the live render, which is how it was caught
+								copyText(patchSnippet(snapshot && snapshot.value ? snapshot.value : {}), setStatus);
+							} },
+							T("settings.copyPatch")),
+						status ? h("span", { style: { fontSize: "11px", opacity: 0.8 } }, status) : null),
+				h("span", { style: { opacity: 0.55, fontSize: "11px" } },
+					T("settings.local")));
+		}
+
+		/**
+		 * The MCP row's configuration card (`plugins.row.config`, key `<bundle>#<row id>`).
+		 *
+		 * The host owns the values and the writes: it hands `{view, form}` where `form.state` is the resolved
+		 * section (schema defaults composed with whatever the user stored) and `form.mutate(ops, revision)`
+		 * is the only write path. The fields are derived from the values rather than hard-coded, so the schema
+		 * in `index.js` stays the single source of truth for what the row accepts.
+		 *
+		 * `view: 'summary'` is what the plugin page puts on the row when the row has no description of its own;
+		 * `view: 'page'` is the form behind its configure control.
+		 */
+		function MisakanetRowConfig(props) {
+			var view = props && props.view;
+			var form = props && props.form;
+			var snapshot = form && form.state ? form.state : null;
+			var resolved = (snapshot && snapshot.value) || {};
+			var draftState = react.useState(null);
+			var draft = draftState[0];
+			var setDraft = draftState[1];
+			var rawState = react.useState({});
+			var raw = rawState[0];
+			var setRaw = rawState[1];
+			var statusState = react.useState(null);
+			var status = statusState[0];
+			var setStatus = statusState[1];
+
+			react.useEffect(function () {
+				try {
+					setDraft(snapshot && snapshot.value ? JSON.parse(JSON.stringify(snapshot.value)) : null);
+					setRaw({});
+				} catch (error) { /* a non-JSON section is not editable here; the read-only note covers it */ }
+			}, [snapshot && snapshot.revision, snapshot && snapshot.status]);
+
+			if (view === "summary") {
+				return h("span", null, String(resolved.transport || "streamable-http") + " → " +
+					String(resolved.url || DEFAULT_MCP_URL));
+			}
+
+			if (!form || !snapshot || snapshot.status !== "ready" || !draft) {
+				// This is the expected state for this row, not a failure. The host builds a form only from
+				// fields its schema marks `volatile()` — ones it can change *without remounting* the plugin
+				// (read out of `dsh-settings`: `volatileForm(schema)` filters on `schema.meta.volatile`, and a
+				// schema with none returns no form at all). An MCP endpoint or transport can only take effect
+				// after a reload, so claiming volatility to win a form would be a lie about this plugin.
+				// What the card can do honestly is show the values in force and say where they are edited.
+				return h("div", { style: { margin: "4px 0", fontSize: "13px", display: "grid", gap: "6px" } },
+					h("p", { style: { margin: 0, opacity: 0.75 } },
+						T("settings.rowReadonly", { row: ROW_ID, what: form ? T("settings.what.form") : T("settings.what.row") })),
+					// The host serves no form here, so hand the reader the text they can paste instead of a dead end.
+					h("div", { style: { display: "inline-flex", alignItems: "center", gap: "8px" } },
+						h("button", { type: "button", style: { cursor: "pointer" },
+							onClick: function () { copyText(patchSnippet(resolved), setStatus); } },
+							T("settings.copyPatch")),
+						status ? h("span", { style: { fontSize: "11px", opacity: 0.8 } }, status) : null),
+					Object.keys(resolved).length
+						? h("table", { style: { borderCollapse: "collapse" } },
+							Object.keys(resolved).map(function (name) {
+								return h("tr", { key: name },
+									h("td", { style: { padding: "2px 10px 2px 0", opacity: 0.7 } }, name),
+									h("td", { style: { fontFamily: "monospace", fontSize: "12px" } }, JSON.stringify(resolved[name])));
+							}))
+						: h("p", { style: { margin: 0, opacity: 0.7 } },
+							T("settings.rowNoValues")));
+			}
+
+			var fields = Object.keys(draft);
+			var readOnly = snapshot.writable === false;
+
+			function change(name, value) {
+				var next = JSON.parse(JSON.stringify(draft));
+				next[name] = value;
+				setDraft(next);
+				setStatus(null);
+			}
+
+			function save() {
+				var ops = [];
+				for (var i = 0; i < fields.length; i++) {
+					var name = fields[i];
+					if (JSON.stringify(resolved[name]) !== JSON.stringify(draft[name])) {
+						ops.push({ op: "set", path: [name], value: draft[name] });
+					}
+				}
+				if (!ops.length) { setStatus({ kind: "ok", text: "Nothing changed." }); return; }
+				setStatus({ kind: "ok", text: "Saving " + ops.length + " field(s)…" });
+				form.mutate(ops, snapshot.revision).then(function (accepted) {
+					setStatus(accepted
+						? { kind: "ok", text: "Saved — the row applies it on the next host start." }
+						: { kind: "error", text: "The host refused the write." });
+				}, function (error) {
+					setStatus({ kind: "error", text: "Write failed: " + ((error && error.message) || String(error)) });
+				});
+			}
+
+			return h("div", { style: { fontSize: "13px", display: "grid", gap: "6px" } },
+				fields.map(function (name) {
+					var value = draft[name];
+					var control;
+					if (typeof value === "boolean") {
+						control = h("input", { type: "checkbox", checked: value, disabled: readOnly,
+							onChange: function (event) { change(name, event.target.checked); } });
+					} else if (typeof value === "number") {
+						control = h("input", { type: "number", value: String(value), disabled: readOnly,
+							style: { width: "10rem" },
+							onChange: function (event) { change(name, Number(event.target.value)); } });
+					} else if (typeof value === "string") {
+						control = h("input", { type: "text", value: value, disabled: readOnly,
+							style: { width: "24rem", maxWidth: "100%" },
+							onChange: function (event) { change(name, event.target.value); } });
+					} else {
+						var text = raw[name] !== undefined ? raw[name] : JSON.stringify(value);
+						control = h("span", { style: { display: "inline-flex", alignItems: "center", gap: "6px" } },
+							h("textarea", { value: text, disabled: readOnly, rows: 3,
+								style: { width: "24rem", maxWidth: "100%", fontFamily: "monospace", fontSize: "12px" },
+								onChange: function (event) {
+									var next = {}; next[name] = event.target.value; setRaw(next);
+									try { change(name, JSON.parse(event.target.value)); } catch (error) { /* keep the text */ }
+								} }),
+							raw[name] !== undefined && !isJson(raw[name])
+								? h("span", { style: { fontSize: "11px", opacity: 0.7 } }, T("settings.invalidJson")) : null);
+					}
+					return h("label", { key: name, style: { display: "flex", alignItems: "center", gap: "8px" } },
+						h("span", { style: { width: "11rem", opacity: 0.8 } }, name), control);
+				}),
+				readOnly
+					? h("p", { style: { margin: 0, opacity: 0.7 } }, T("settings.noWrites"))
+					: h("div", { style: { display: "flex", alignItems: "center", gap: "10px" } },
+						h("button", { type: "button", onClick: save, style: { cursor: "pointer" } }, T("settings.save")),
+						status ? h("span", { style: { opacity: 0.8 } }, status.text) : null));
+		}
+
+		/**
+		 * The `/misakanet` result overlay, rendered inside the resident composer card
+		 * (`conversation.input.overlay`, session scope).
+		 *
+		 * It is the one place in this half that asks the server for something the session does not already
+		 * have, so it also says what it sends: the query, anonymously, to `misakanet.org`.
+		 */
+		function MisakanetSearchOverlay(props) {
+			var sessionId = props && props.sessionId;
+			var revisionState = react.useState(0);
+			var setRevision = revisionState[1];
+			react.useEffect(function () {
+				return subscribe(sessionId, function () { setRevision(function (n) { return n + 1; }); });
+			}, [sessionId]);
+			react.useEffect(function () { return subscribePrefs(function () { setRevision(function (n) { return n + 1; }); }); }, []);
+			react.useEffect(function () { return subscribeLocale(function () { setRevision(function (n) { return n + 1; }); }); }, []);
+			if (!sessionId) return null;
+			var state = overlayOf(sessionId);
+			if (!state.open) return null;
+
+			var body;
+			if (state.status === "loading") {
+				body = h("div", { style: { opacity: 0.7, fontSize: "12px", padding: "6px 2px" } }, T("overlay.searching"));
+			} else if (state.status === "error") {
+				body = h("div", { style: { fontSize: "12px", padding: "6px 2px" } },
+					T("overlay.failed", { error: state.error }));
+			} else if (state.status === "idle") {
+				body = h("div", { style: { opacity: 0.7, fontSize: "12px", padding: "6px 2px" } },
+					T("overlay.empty"));
+			} else if (!state.results.length) {
+				body = h("div", { style: { fontSize: "12px", padding: "6px 2px" } },
+					T("overlay.none"));
+			} else {
+				body = h("div", null, state.results.map(MisakanetOverlayRow));
+			}
+
+			// `Canvas`/`CanvasText` are CSS system colours: they follow the host's light/dark theme without
+			// this file knowing its variables, and the opaque background is what keeps the composer's own
+			// text from showing through the card (measured: a transparent card overlapped the tool row).
+			return h("div", {
+				style: { border: "1px solid rgba(127,127,127,0.35)", borderRadius: "12px", padding: "8px 10px",
+					margin: "6px 0", maxHeight: "320px", overflowY: "auto", fontSize: "13px",
+					position: "relative", zIndex: 3, background: "Canvas", color: "CanvasText",
+					boxShadow: "0 8px 24px rgba(0,0,0,0.18)" },
+			}, h("div", { style: { display: "flex", alignItems: "center", gap: "6px", marginBottom: "4px" } },
+				MisakanetGlyph({ size: 14 }),
+				h("span", { style: { fontWeight: 600 } }, "MisakaNet"),
+				state.query ? h("span", { style: { opacity: 0.6, fontSize: "12px" } }, "· " + state.query) : null,
+				h("span", { style: { flex: 1 } }),
+				h("button", {
+					type: "button", title: T("overlay.close"),
+					onClick: function () { setOverlay(sessionId, { open: false }); },
+					style: { background: "none", border: "none", cursor: "pointer", color: "inherit", opacity: 0.7 },
+				}, "×")),
+				body,
+				h("div", { style: { opacity: 0.55, fontSize: "11px", marginTop: "4px" } },
+					T("overlay.footnote")));
+		}
+
+		/**
+		 * The `/misakanet` source for the host's slash pipeline.
+		 *
+		 * The pipeline owns the draft: picking the candidate claims the token (so the composer says what is
+		 * about to happen) and Enter then hands us the argument through `submit`. We answer with the
+		 * overlay instead of consuming the submit, which is why this is a claim and not an insert.
+		 */
+		function misakanetTrigger(lastSession) {
+			return {
+				trigger: "/",
+				name: "misakanet",
+				order: 5,
+				candidates: function (session, request) {
+					if (session && session.sessionId) lastSession.id = session.sessionId;
+					if (!request || request.position !== "leading") return Promise.resolve([]);
+					var query = String(request.query || "").trim().toLowerCase();
+					if (query !== "" && "misakanet".indexOf(query) !== 0) return Promise.resolve([]);
+					return Promise.resolve([{
+						name: "misakanet",
+						label: "MisakaNet search",
+						description: "Search the failure-lesson library without leaving the composer",
+						icon: MisakanetGlyph,
+						section: "MisakaNet",
+					}]);
+				},
+				onPick: function () {
+					return { claim: {
+						name: "misakanet",
+						token: "/misakanet ",
+						hint: "what broke?",
+						submit: function (args) {
+							var sessionId = lastSession.id;
+							var query = String(args || "").trim();
+							if (!query) {
+								runOverlaySearch(sessionId, "");
+								return Promise.resolve({ kind: "error",
+									text: "Type what broke after /misakanet — e.g. /misakanet pip install timeout" });
+							}
+							runOverlaySearch(sessionId, query);
+							return Promise.resolve({ kind: "success" });
+						},
+					} };
+				},
+			};
+		}
+
 		/**
 		 * The left column's icon seat (`sidebar.panellist`, root scope → it does not come and go with a
 		 * session). The owner supplies `{size, active}` and owns the button: the id we register here is the
@@ -938,8 +1857,7 @@ window.__ModuleLoader__.load({
 			return h("div", { style: { height: "100%", overflowY: "auto", padding: "28px 32px 48px" } },
 				h("div", { style: { maxWidth: "860px", margin: "0 auto" } },
 					h("p", { style: { margin: "0 0 14px", color: "inherit", opacity: 0.7, fontSize: "13px", lineHeight: "1.5" } },
-						"The left column opens this page; the session-scoped counters live in the session's " +
-						"right-sidebar MisakaNet tab. The numbers here are what this browser has contributed."),
+						T("main.footnote")),
 					h(MisakanetPanel, { sessionId: props && props.sessionId })));
 		}
 
@@ -1014,6 +1932,97 @@ window.__ModuleLoader__.load({
 				{ name: "main", key: PANEL_ID },
 				MisakanetMainView, "main panel");
 
+			// The composer: a result overlay above the input, and the `/misakanet` source that opens it.
+			// The source is a *service* inject, not a slot — the slash pipeline owns the draft, so the
+			// interesting contract is `registerSource`, and a host without that service keeps every other
+			// seat instead of failing activation.
+			// The plugin page's row: the key is `<bundle>#<row id>` as the patch declares it. Without the
+			// host's `form` the card renders the resolved values read-only, which is also what a host that
+			// serves no schema for the row gets.
+			// Two keys, because the plugin page looks a form up twice with different names: the bundle's own
+			// config is keyed by the **package name** (`ItemDetail` → `formFor(item.id)`), while a row's is
+			// keyed by the **row id** (`RowDetail` → `formFor(row.rowId)`). Whichever namespace the host
+			// actually documents, one of these finds it — and the card renders read-only values when neither
+			// does, so the entry is never a dead end.
+			// The dictionaries and the binding. `bind` keeps a stable identity and reads the active locale on
+			// every call, so one binding serves every component; the subscription is what lets an already
+			// rendered surface switch language without a reload.
+			step("dictionaries", function () {
+				if (typeof ctx.inject !== "function") throw new Error("ctx.inject is not available");
+				return ctx.inject(["locale"], function (scoped) {
+					var locale = scoped && (scoped.locale ||
+						(typeof scoped.get === "function" ? scoped.get("locale") : undefined));
+					if (!locale || typeof locale.register !== "function" || typeof locale.bind !== "function") {
+						return undefined;   // no locale service: the surfaces stay in English, the source text
+					}
+					localeFace = locale;
+					T = locale.bind(NS);
+					var stops = [];
+					if (typeof locale.subscribe === "function") {
+						stops.push(locale.subscribe(function () { notifyLocale(); }));
+					}
+					return ctx.effect(function () {
+						var disposer = locale.register(NS, { en: en, zh: zh });
+						return function () {
+							for (var i = 0; i < stops.length; i++) {
+								if (typeof stops[i] === "function") stops[i]();
+							}
+							if (typeof disposer === "function") disposer();
+						};
+					}, "misakanet: dictionaries");
+				});
+			});
+
+			// The two frame-wide seats. Both are root scope and receive no `sessionId`, which is why the store
+			// tracks the most recently touched session for them.
+			registerWhenDeclared("shell.overlay",
+				{ name: "shell.overlay", id: "misakanet-lesson-toast", order: 30, label: function () { return "MisakaNet"; } },
+				MisakanetShellToast, "shell overlay");
+			registerWhenDeclared("sidebar.footer.action",
+				{ name: "sidebar.footer.action", id: "misakanet-summary", order: 40,
+					label: function () { return T("footer.action"); } },
+				MisakanetFooterAction, "footer action");
+			// The settings row. `configForms` is a service, so it is read defensively: a host without it keeps
+			// the row's browser preferences and loses only the endpoint field.
+			step("settings row", function () {
+				var face = {};
+				try {
+					if (ctx.configForms && typeof ctx.configForms.get === "function") {
+						var form = ctx.configForms.get(ROW_ID);
+						if (form && typeof form.getSnapshot === "function" && typeof form.set === "function") {
+							face.hostForm = form;
+						}
+					}
+				} catch (error) { /* the row still carries its two browser preferences */ }
+				return ctx.effect(function () {
+					return ctx.slots.inject("settings.general.item", function () {
+						return ctx.slots.register({
+							name: "settings.general.item", id: PANEL_ID, order: 50,
+							inject: function () { return { hooks: face }; },
+						}, MisakanetSettingsRow);
+					});
+				}, "misakanet: settings row");
+			});
+			registerWhenDeclared("plugins.bundle.config",
+				{ name: "plugins.bundle.config", key: "misakanet" },
+				MisakanetRowConfig, "bundle config");
+			registerWhenDeclared("plugins.row.config",
+				{ name: "plugins.row.config", key: "misakanet#misakanet-mcp" },
+				MisakanetRowConfig, "row config");
+			registerWhenDeclared("conversation.input.overlay",
+				{ name: "conversation.input.overlay", id: "misakanet-search", order: 20 },
+				MisakanetSearchOverlay, "search overlay");
+			step("slash command", function () {
+				if (typeof ctx.inject !== "function") throw new Error("ctx.inject is not available");
+				var lastSession = { id: null };
+				return ctx.inject(["inputTriggers"], function (scoped) {
+					var triggers = scoped && (scoped.inputTriggers ||
+						(typeof scoped.get === "function" ? scoped.get("inputTriggers") : undefined));
+					if (!triggers || typeof triggers.registerSource !== "function") return undefined;
+					return triggers.registerSource(misakanetTrigger(lastSession));
+				});
+			});
+
 			// The right sidebar ships from 0.1.5 on, so this rides a deferred service inject: on a line
 			// without the registry the callback never runs, the fiber never pends, and the conversation tab
 			// above is the whole plugin. Inside, the registry is re-proved and every disposer is collected.
@@ -1041,7 +2050,7 @@ window.__ModuleLoader__.load({
 								id: "panel",
 								order: 30,
 								title: function () { return "MisakaNet"; },
-								description: function () { return "What this session asked, what came back, and what you filed"; },
+								description: function () { return T("guide.description"); },
 								icon: MisakanetGlyph,
 							}],
 						}));