misakanet 2.44.1 → 2.45.0

package/lib/client.js

@@ -27,12 +27,14 @@
  *   screen, and the only surface from which a human can speak about it.
  *
  * Why the vote is worth this much care: `POST /api/helpful` is the **only** writer of the counter that
- * `misakanet_me_events` reports as `lesson_found_helpful`, so one click is what turns a private success
- * into reuse evidence every later agent can read (the event appears at one vote, `E4` at two). Three
- * rules follow, and they explain several odd-looking details below:
+ * `misakanet_me_events` reports as `lesson_found_helpful`. That event is a *hint*, not the rung: since
+ * 2026-10-16 a vote is capped below `E4` at every count (measured then: 3 of the 24 most-retrieved
+ * lessons carried any vote, 6 votes in total, 0 of 483 lessons at `E4`), because the person shown the
+ * button did not ask the question, and the reuse the rung is about is observable at the transport
+ * layer instead. Three rules follow, and they explain several odd-looking details below:
  *
  * 1. **Never vote on the human's behalf.** No auto-vote on a successful build, no default selection,
- *    no pre-checked box: `E4` is worth something only because a person said it.
+ *    no pre-checked box: a vote means something only because a person chose to give it.
  * 2. **Abstention is free and is the default.** Doing nothing is a first-class outcome — the buttons
  *    appear, and nothing nags if they are ignored.
  * 3. **Say what each action sends.** 👍 posts the lesson id and nothing else. 👎 has to carry the search
@@ -126,17 +128,20 @@ window.__ModuleLoader__.load({
 		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.asked.none": "No MisakaNet search has run in this session yet — the entry point is the composer: type /misakanet, then what broke.",
 			"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.trust.none": "No lesson surfaced yet — the entry point is the composer: type /misakanet, then what broke.",
+			"panel.hint.open": "Open the search box over the composer",
+			"panel.hint.openLabel": "Open the search box",
+			"panel.hint.openTitle": "Opens the composer's own MisakaNet overlay, which carries the same instruction. It does not type into the composer: a view occupant receives props, and the draft is reachable only from a live session scope, so nothing here can put `/misakanet ` in the box for you.",
 			"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.empty": "After /misakanet, type what broke, 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.",
@@ -169,11 +174,15 @@ window.__ModuleLoader__.load({
 			"unit.votes": "votes",
 			"unit.report": "report",
 			"unit.reports": "reports",
+			"unit.reportFiled": "report filed",
+			"unit.reportsFiled": "reports filed",
+			"unit.retrieval": "retrieval",
+			"unit.retrievals": "retrievals",
 			"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.nothingFound": "found nothing",
 			"panel.asked.voteHelpful": "Helpful",
 			"panel.asked.voteNotHelpful": "not helpful",
 			"panel.asked.voteNone": "not voted",
@@ -181,13 +190,35 @@ window.__ModuleLoader__.load({
 			"panel.asked.voteHint": "Same action as the verdict beside the assistant message, without scrolling back to it. Sends this lesson's id and one constant label (`dsh-web`); nothing else.",
 			"panel.asked.voteFailed": "could not reach misakanet.org — nothing was recorded",
 			"panel.asked.voteOne": "1 human confirmation — the reuse event now appears (E3: a reuse signal, not CI verification).",
-			"panel.asked.voteTwo": "2 human confirmations — enough for agents to read this as E4.",
-			"panel.asked.voteMore": "human confirmations — enough for agents to read this as E4.",
+			"panel.asked.voteTwo": "2 human confirmations — recorded as a hint; the E4 rung comes from observable reuse, not a vote.",
+			"panel.asked.voteMore": "human confirmations — recorded as a hint; the E4 rung comes from observable reuse, not a vote.",
 			"panel.asked.noMatchTag": "no match",
 			"panel.asked.agentNext": "Hand this line to the agent:",
 			"panel.asked.agentNextCopy": "Copy the next step",
 			"panel.asked.agentNextText": "Please record this gap with the MisakaNet intake so the next person finds it: misakanet_submit_intake problem: ",
 			"panel.asked.agentNextWhy": "This page cannot file it: a report is re-checked by submitting the same text again, the server's dedup window is finite, and a page-triggered submit could open a second issue for one problem.",
+			// The retrieval ranking is the network's own observation, not this session's, and it is not a
+			// judgment. Every word is a lookup for the same reason the counters are — a zh reader has to get
+			// zh — and the one thing none of these strings may say is that the order is approval: the count
+			// is how often a search put that lesson first, which says nothing about whether it helped.
+			"panel.hot": "What the corpus returns most",
+			"panel.hot.loading": "reading the network's retrieval ranking…",
+			"panel.hot.none": "The analytics endpoint ranked no lesson, so this section shows nothing rather than a zero.",
+			"panel.hot.rule": "Each number is how many times a search ranked that lesson as its top hit — a retrieval count from the network's own analytics. It is an observed count, not a vote, not an approval, and not evidence that the lesson helped.",
+			"panel.hot.limit": "The {n} most-retrieved lessons — the endpoint returns more, so this list stops at {n}.",
+			"panel.hot.noCount": "the endpoint did not report a count",
+			// The coverage read answers the *other* half of the same question, and it must not read as a
+			// second version of the ranking above: section ⑥ counts what searches brought back, this counts
+			// what they did not find. Every visible word is a lookup for the same reason the counters are,
+			// and the one thing none of these strings may say is that the order is an opinion — it is a
+			// count of unanswered searches.
+			"panel.coverage": "The topics the corpus cannot answer yet",
+			"panel.coverage.loading": "reading the network's coverage board…",
+			"panel.coverage.none": "The coverage board ranked no topic, so this section shows nothing rather than a guess.",
+			"panel.coverage.rule": "The ranking above counts what searches brought back; this one counts what they did not find. Each row is a topic with the last 30 days' unanswered searches, read from the network's own coverage board, and the number of published lessons that match it.",
+			"panel.coverage.lessonsTpl": "{count} in the corpus · ",
+			"panel.coverage.unsolvedTpl": "{count} found nothing in 30 days",
+			"panel.coverage.totals": "{count} published in all · the topics below are the ones with the most unanswered searches",
 			"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 ",
@@ -208,12 +239,9 @@ window.__ModuleLoader__.load({
 			"panel.trust.used": " · used ",
 			"panel.trust.external": "external reuse evidence: ",
 			"panel.trust.declared": "declared: ",
-			"panel.trust.e4signal": "live signal: E4",
-			"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.trust.footnote": "The level is the lesson's own stored evidence; the count is other people's votes, not yours — recorded as a hint, never as proof. Agents read E4 only from observable reuse, which a vote cannot confer.",
 			"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 (",
@@ -221,7 +249,7 @@ window.__ModuleLoader__.load({
 			"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.",
+			"panel.footnote": "Every number above comes from this conversation's own transcript rows plus one public GET per lesson (/api/helpful), one read of the network's retrieval ranking (/api/analytics) and one read of its coverage board (/api/insights/lesson-coverage). 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",
@@ -240,7 +268,23 @@ window.__ModuleLoader__.load({
 			"settings.invalidJson": "invalid JSON",
 			"settings.what.form": "form",
 			"settings.what.row": "row",
-			"panel.activity.withLesson": " with a lesson · ",
+			// The counter strip and the activity line below are the two places a reader meets these
+			// numbers, and every word between them is a lookup: the unit words are `unit.*`, the rest are
+			// one-slot templates. Both halves are needed, because where the words go differs — English
+			// writes the plural noun then the verb (`{count} surfaced`), a language that takes a measure
+			// word before its noun writes one phrase (`{n} {unit}命中过课程`). Concatenating either half at
+			// the call site is what made the Chinese panel read `0 with a lesson · 0 lessons surfaced`,
+			// and splitting the phrase across two slots later made it read `1 篇 篇被课程复用`.
+			"panel.strip.hitTpl": "{count} hit · ",
+			"panel.strip.missTpl": "{count} found nothing · ",
+			"panel.strip.surfacedTpl": "{count} surfaced · ",
+			"panel.strip.helpfulTpl": "({n} helpful) · ",
+			"panel.strip.convertedTpl": "({n} became a lesson)",
+			"panel.activity.reusedTpl": "{count} reused · ",
+			"panel.activity.reportsTpl": "{count} · ",
+			"panel.activity.filedTpl": "{count}",
+			"unit.conversion": "conversion",
+			"unit.conversions": "conversions",
 			"footer.session": "session: ",
 			"footer.actionHint": "Copy the MisakaNet summary of the session that last used it",
 			"settings.copyPatch": "Copy patch snippet",
@@ -250,17 +294,20 @@ window.__ModuleLoader__.load({
 		var zh = {
 			"guide.description": "本会话问过什么、拿回了什么、你报了什么",
 			"panel.asked": "本会话问过什么",
-			"panel.asked.none": "本会话还没有发起过 MisakaNet 检索。",
+			"panel.asked.none": "本会话还没有发起过 MisakaNet 检索 —— 入口就在输入框：先打 /misakanet，再写清楚出了什么问题。",
 			"panel.reports": "你报过的问题",
 			"panel.reports.none": "本会话没有报过任何问题。",
 			"panel.trust": "这些课程的可信度",
-			"panel.trust.none": "还没有命中过课程。",
+			"panel.trust.none": "还没有命中过课程 —— 入口就在输入框：先打 /misakanet，再写清楚出了什么问题。",
+			"panel.hint.open": "在输入框上方打开检索框",
+			"panel.hint.openLabel": "打开检索框",
+			"panel.hint.openTitle": "打开输入框自己的 MisakaNet 浮层，里面写着同样的用法。它不会替你在输入框里打字：视图组件只拿得到 props，草稿只有活的 session 作用域才能改，所以从这里没办法替你填入「/misakanet 」。",
 			"panel.activity": "你的活动",
 			"panel.voice": "语音",
 			"panel.voice.on": "语音提示：开",
 			"panel.voice.off": "语音提示：关",
 			"overlay.searching": "检索中……",
-			"overlay.empty": "在 /misakanet 后面写清楚出了什么问题，例如 /misakanet pip install 超时",
+			"overlay.empty": "在 /misakanet 后面写清楚出了什么问题，例如 /misakanet pip install 超时。",
 			"overlay.none": "还没有课程覆盖这个问题。可以让 agent 报料（misakanet_submit_intake），或直接去 misakanet.org 提交 —— 下一个人就能在这里搜到它。",
 			"overlay.failed": "检索失败：{error} —— 课程库在 misakanet.org；这次只发出了查询本身。",
 			"overlay.footnote": "读取是匿名的。这个浮层只把查询发给 misakanet.org；除此之外，页面只会发出你的投票与报料。",
@@ -293,11 +340,15 @@ window.__ModuleLoader__.load({
 			"unit.votes": "票",
 			"unit.report": "条报料",
 			"unit.reports": "条报料",
+			"unit.reportFiled": "条报料",
+			"unit.reportsFiled": "条报料",
+			"unit.retrieval": "次检索",
+			"unit.retrievals": "次检索",
 			"panel.asked.searching": "检索中……",
 			"panel.asked.noMatch": "没有命中任何课程",
 			"panel.asked.top": "· 最佳：",
 			"panel.asked.noQuery": "（没记下查询原文）",
-			"panel.asked.nothingFound": "没有命中",
+			"panel.asked.nothingFound": "没查到结果",
 			"panel.asked.voteHelpful": "有用",
 			"panel.asked.voteNotHelpful": "没用",
 			"panel.asked.voteNone": "未投票",
@@ -305,13 +356,26 @@ window.__ModuleLoader__.load({
 			"panel.asked.voteHint": "与助手消息旁的裁决行是同一个动作，不用再往回滚。只发这篇课程的 id 和一个固定标签（`dsh-web`），不发别的。",
 			"panel.asked.voteFailed": "连不上 misakanet.org —— 这次没有记下任何东西",
 			"panel.asked.voteOne": "1 个人工确认 —— 复用事件现在出现了（E3：复用信号，不是 CI 验证）。",
-			"panel.asked.voteTwo": "2 个人工确认 —— 已经是 agent 读到的 E4 了。",
-			"panel.asked.voteMore": "个人工确认 —— 已经是 agent 读到的 E4 了。",
+			"panel.asked.voteTwo": "2 个人工确认 —— 只记为提示，不算证据：E4 那一档来自可观测的复用，投票给不了。",
+			"panel.asked.voteMore": "个人工确认 —— 只记为提示，不算证据：E4 那一档来自可观测的复用，投票给不了。",
 			"panel.asked.noMatchTag": "无命中",
 			"panel.asked.agentNext": "把这行交给 agent：",
 			"panel.asked.agentNextCopy": "复制下一步",
 			"panel.asked.agentNextText": "请用 MisakaNet 报料记下这个缺口，让下一个人能搜到：misakanet_submit_intake problem: ",
 			"panel.asked.agentNextWhy": "这个页面不能替你报：报料的复查方式是原样再提交一次，而服务端的去重窗口是有限的 —— 页面触发的提交可能为同一个问题开出第二个 issue。",
+			"panel.hot": "全网返回最多的课程",
+			"panel.hot.loading": "正在读全网的检索排行……",
+			"panel.hot.none": "统计端点没有排出任何课程 —— 这一节宁可什么都不显示，也不编造一个 0。",
+			"panel.hot.rule": "每个数字是这篇课程被检索结果排到首位的次数 —— 来自网络自己的统计端点。它是一个观测到的计数：不是投票，不是认可，也不代表这篇课程真的帮上了忙。",
+			"panel.hot.limit": "检索次数最多的 {n} 篇课程 —— 端点返回的更多，这里只列到第 {n} 篇。",
+			"panel.hot.noCount": "端点没有给出次数",
+			"panel.coverage": "语料还答不上来的主题",
+			"panel.coverage.loading": "正在读网络的覆盖看板……",
+			"panel.coverage.none": "覆盖看板没有排出任何主题 —— 这一节宁可什么都不显示，也不猜。",
+			"panel.coverage.rule": "上面那一节数的是检索带回来了什么；这一节数的是没找到什么。每一行是一个主题，配最近 30 天里没有拿到答案的检索次数（读的是网络自己的覆盖看板），以及语料里匹配该主题的已发布课程数。",
+			"panel.coverage.lessonsTpl": "{n} {unit}在库 · ",
+			"panel.coverage.unsolvedTpl": "30 天内 {n} {unit}没有答案",
+			"panel.coverage.totals": "{n} {unit}已发布 · 下面是没有答案的检索最多的主题",
 			"panel.counters": "本会话 · 计数只存在本浏览器 · 没有账号，除了你的投票与报料，不上传任何东西",
 			"panel.report.title": "MisakaNet 报料",
 			"panel.report.coveredBy": "已被 ",
@@ -332,12 +396,9 @@ window.__ModuleLoader__.load({
 			"panel.trust.used": " · 已复用 ",
 			"panel.trust.external": "外部复用证据：",
 			"panel.trust.declared": "课程自述：",
-			"panel.trust.e4signal": "实时信号：E4",
-			"panel.trust.footnote": "等级来自课程自己存的证据；计数是别人的确认，不是你的：前者让复用事件出现，后者才是 agent 读到的 E4。",
+			"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": "提示音是服务端为上一次检索自己选的（",
@@ -345,7 +406,7 @@ window.__ModuleLoader__.load({
 			"panel.voice.none": "还没有提示音：服务端会在本会话第一次检索时给出。",
 			"panel.voice.play": "播放“",
 			"panel.voice.hook": "本地钩子是另一回事：用 --voice 安装，用 MISAKANET_VOICE=0 静音，通过本机自己的播放器发声，还能弹桌面通知。页面读不到也改不了它，所以这个面板不报告它的状态。",
-			"panel.footnote": "上面的数字都来自本次对话自己的转录，外加每篇课程一次公开 GET（/api/helpful）。可信计数是别人的确认，不是你自己的。重载窗口会丢掉会话行，浏览器计数会留下。这里的回执是 agent 自己调用返回的东西 —— 待处理报料会在 agent 再次提问时复查，而不是这个页面。",
+			"panel.footnote": "上面的数字都来自本次对话自己的转录，外加每篇课程一次公开 GET（/api/helpful）、一次对全网检索排行的读取（/api/analytics）和一次对覆盖看板的读取（/api/insights/lesson-coverage）。可信计数是别人的确认，不是你自己的。重载窗口会丢掉会话行，浏览器计数会留下。这里的回执是 agent 自己调用返回的东西 —— 待处理报料会在 agent 再次提问时复查，而不是这个页面。",
 			"main.footnote": "左栏打开的就是这一页；会话级的计数在右栏的 MisakaNet 标签里。这里的数字是本浏览器贡献的部分。",
 			"tool.rawResult": "原始结果",
 			"tool.readFailed": "结果读不出来",
@@ -364,7 +425,16 @@ window.__ModuleLoader__.load({
 			"settings.invalidJson": "JSON 不合法",
 			"settings.what.form": "表单",
 			"settings.what.row": "条目",
-			"panel.activity.withLesson": " 篇命中课程 · ",
+			"panel.strip.hitTpl": "{n} {unit}命中过课程 · ",
+			"panel.strip.missTpl": "{n} {unit}没命中 · ",
+			"panel.strip.surfacedTpl": "{n} {unit}命中过课程 · ",
+			"panel.strip.helpfulTpl": "（{n} 有用） · ",
+			"panel.strip.convertedTpl": "（{n} 转化为课程）",
+			"panel.activity.reusedTpl": "{n} {unit}被课程复用 · ",
+			"panel.activity.reportsTpl": "{n} {unit} · ",
+			"panel.activity.filedTpl": "{n} {unit}",
+			"unit.conversion": "次转化",
+			"unit.conversions": "次转化",
 			"footer.session": "会话：",
 			"footer.actionHint": "复制最近一次使用 MisakaNet 的那个会话的摘要",
 			"settings.copyPatch": "复制 patch 片段",
@@ -620,6 +690,38 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 		var OVERLAY_LIMIT = 5;
 		var OVERLAY_TIMEOUT_MS = 8000;
 
+		/**
+		 * How many rows section ⑥ shows of `/api/analytics`'s `top_lessons`.
+		 *
+		 * The owner asked for five and the endpoint returns ten, so the list is capped — and the cap is
+		 * *printed* by the section (`panel.hot.limit`) rather than applied silently, because a reader who
+		 * cannot see where a ranking was cut cannot tell it from a ranking that ended.
+		 */
+		var HOT_LESSON_LIMIT = 5;
+
+		/**
+		 * Section ⑦'s target, and the three reads it was chosen over.
+		 *
+		 * `/api/insights/lesson-coverage` is the other half of section ⑥'s question, not a second version
+		 * of it: ⑥ borrows `/api/analytics` to rank *retrievals* — which lessons searches brought back —
+		 * while this ranks *unmet demand*: `gaps` is ordered by `unsolved30d`, the searches in the last 30
+		 * days that ended with no usable answer, and each row carries `lessonCount`, the published lessons
+		 * that do match that topic. A reader who sees both should never think they are two orderings of the
+		 * same number, which is what `panel.coverage.rule` says out loud.
+		 *
+		 * Of the four candidate reads measured live 2026-10-16 (all four answering
+		 * `access-control-allow-origin: *`, so no server change is needed), this is the only one that both
+		 * ranks something and says how much knowledge stands behind it. The others: `/api/insights/demand-board`
+		 * is 146 bytes of family counters with no lesson counts in it; `/api/search-signals/stats` is 705 rows
+		 * of `{solved, created_at}` — one per search, no lesson id — an unranked event log; `/api/lessons` is
+		 * the corpus with no retrieval signal in any field, so any "hottest" order over it would be invented
+		 * here. None of the four exposes a per-lesson retrieval count, which is why ⑥ and ⑦ split the
+		 * question the way they do: ⑥ has the lessons and no topics, ⑦ has the topics and no individual
+		 * lessons. The finest grain ⑦ can honestly speak at is the task family.
+		 */
+		var COVERAGE_ENDPOINT = "https://misakanet.org/api/insights/lesson-coverage";
+		var COVERAGE_LIMIT = 5;
+
 		/**
 		 * The label every vote from this browser half carries: what cast it, not who.
 		 *
@@ -959,11 +1061,21 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 		 *
 		 * `many` is explicit rather than `singular + "s"` because English is not regular: the first
 		 * version of this helper printed "2 searchs", which its own verification run showed and the
-		 * commit message then misquoted. Passing the plural at the call site makes the irregular one
-		 * impossible to get wrong silently.
+		 * commit message then misquoted.
+		 *
+		 * The fallback keeps `many` optional, but it may only ever *derive an English plural*. A unit
+		 * that is not an English word — every `unit.*` key holds a Chinese one under zh — does not
+		 * pluralize with a trailing "s", so appending one did not make the count wrong in a way a reader
+		 * could parse: it made `count(0, "票")` print `"票s"` and `count(0, "转化")` print `"转化s"`,
+		 * which is the screenshot this file was fixed from. A unit that is not `[A-Za-z]…` therefore
+		 * keeps its singular in the plural slot, and the guard is the *character class*, not a list of
+		 * nouns: a new unit in a language this helper has never seen cannot grow an English plural.
+		 * Where English itself is irregular the call site still passes `many`, because no default can
+		 * know "search" wants "searches".
 		 */
 		function count(n, singular, many) {
-			return n + " " + (n === 1 ? singular : many || singular + "s");
+			var plural = many || (/^[A-Za-z][A-Za-z '\u2019-]*$/.test(singular) ? singular + "s" : singular);
+			return n + " " + (n === 1 ? singular : plural);
 		}
 
 		/** mm:ss for today, else the date — the event's own time, never the render time. */
@@ -1218,7 +1330,9 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 		 * counters — the review surface, as opposed to the two judging/visibility rows in the transcript.
 		 *
 		 * Every number here has a named source: this session's own log (the rows above), the browser's own
-		 * counters, one public `GET /api/helpful` per lesson, and nothing else. The limits are printed in
+		 * counters, one public `GET /api/helpful` per lesson, one read of the network's retrieval ranking
+		 * (`GET /api/analytics`, section ⑥), one read of its coverage board
+		 * (`/api/insights/lesson-coverage`, section ⑦), and nothing else. The limits are printed in
 		 * the panel rather than hidden: a reload loses the log, and the local voice hook is not ours to
 		 * read.
 		 */
@@ -1237,6 +1351,19 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 			var voteState = react.useState({});
 			var panelVotes = voteState[0];
 			var setPanelVotes = voteState[1];
+			// The retrieval read's own state, and deliberately a third value: `undefined` is "not answered
+			// yet", `null` is "asked and there is no ranking". Collapsing them would make the first paint
+			// say the endpoint ranked nothing, which is a claim the page has not earned yet — and it would
+			// leave no way to tell an empty ranking from one still in flight.
+			var hotState = react.useState(undefined);
+			var hot = hotState[0];
+			var setHot = hotState[1];
+			// Section ⑦'s own state, and the same third value for the same reason: `undefined` is "not
+			// answered yet", `null` is "asked and there is no ranking". Collapsing them would make the first
+			// paint say the board ranked nothing, which is a claim the page has not earned yet.
+			var coverageState = react.useState(undefined);
+			var coverage = coverageState[0];
+			var setCoverage = coverageState[1];
 
 			react.useEffect(function () {
 				return subscribe(sessionId, function () {
@@ -1293,6 +1420,82 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 				}
 			}, [revisionState[0], lessons.length]);
 
+			// ⑥ the network's most-retrieved lessons, read once per mount.
+			//
+			// The owner asked to see the corpus's hottest lessons without waiting for an agent to surface
+			// one, and the ranking that needs already exists: `GET /api/analytics` — public, `no-store`, and
+			// `access-control-allow-origin: *` (measured 2026-10-16) — carries `top_lessons`, one
+			// `{lesson_id, count}` per lesson, ordered by how often that lesson came back as a search's top
+			// hit.
+			//
+			// **Why this endpoint and not the coverage board** (`/api/insights/lesson-coverage`, the read
+			// PR #3351 adds): the two rank different things and both are honest. The coverage board ranks
+			// *topics* by unmet demand (`unsolved30d`, searches that ended with no usable answer) and says
+			// how many lessons match each topic; it carries no per-lesson retrieval count at all, so a
+			// "hottest lesson" list read from it would be invented here. This endpoint ranks retrievals and
+			// says nothing about whether the lesson helped — a price the section states out loud rather than
+			// dressing the count as a verdict.
+			//
+			// **What is deliberately not rendered: `top_searches`**, the same payload's unfiltered query
+			// list. On 2026-10-16 it led with `pip install timeout` and `Error response from daemon: exit
+			// code 137`, then with `npm run build`, `init` and `start` — generic strings a build tool or a
+			// shell prompt emits, not failure topics. It also carries no lesson link, so it cannot be paired
+			// with the answer that satisfied it. Rendering it as "what people ask" would put noise on the
+			// panel at the same weight as knowledge, so this section shows the ranking the payload really
+			// provides and leaves the query list alone. Nothing here averages it in.
+			//
+			// The read is scheduled, never awaited on the render path: the panel's first paint must not wait
+			// on misakanet.org. `askedHot` is the same once-only guard the per-lesson `GET /api/helpful`
+			// uses, because the effect can re-run and a public endpoint should not be asked twice for one
+			// answer.
+			var askedHot = react.useRef(false);
+			react.useEffect(function () {
+				if (askedHot.current) return;
+				askedHot.current = true;
+				fetch(API + "/api/analytics")
+					.then(function (response) { return response.ok ? response.json() : null; })
+					.then(function (body) {
+						var ranked = body && Array.isArray(body.top_lessons) ? body.top_lessons : null;
+						// An absent or empty `top_lessons` is "no ranking", never a zero: a manufactured `0`
+						// would name a lesson the endpoint did not rank.
+						setHot(ranked && ranked.length ? ranked : null);
+					})
+					.catch(function () { setHot(null); });
+			}, []);
+
+			// ⑦ what the corpus cannot answer yet, read once per mount.
+			//
+			// The complement of ⑥, and deliberately not a re-sort of it. ⑥ ranks *lessons by retrievals*
+			// (`/api/analytics`'s `top_lessons`); this ranks *topics by unanswered searches*
+			// (`/api/insights/lesson-coverage`'s `gaps`, `unsolved30d` descending) and prints how many
+			// published lessons match each topic. Two different measurements of two different things: what
+			// the corpus returns most, and where it has nothing to return. `panel.coverage.rule` states the
+			// difference where the reader meets it, because a panel with two rankings that never says how
+			// they differ invites the reader to assume one is a re-sort of the other.
+			//
+			// Why this endpoint rather than `/api/analytics`: the retrieval ranking carries no topic and no
+			// gap count, and none of the four reads measured on 2026-10-16 carries a per-lesson retrieval
+			// count *and* a topic. `gaps` is the only public ranking of unmet demand, and `lessonCount` is
+			// the only public statement of how much knowledge stands behind each topic.
+			//
+			// Scheduled, never awaited on the render path — the first paint must not wait on misakanet.org —
+			// and guarded by a ref for the same reason as ⑥: the effect can re-run and a public endpoint
+			// should not be asked twice for one answer.
+			var askedCoverage = react.useRef(false);
+			react.useEffect(function () {
+				if (askedCoverage.current) return;
+				askedCoverage.current = true;
+				fetch(COVERAGE_ENDPOINT)
+					.then(function (response) { return response.ok ? response.json() : null; })
+					.then(function (body) {
+						var ranked = body && body.success && Array.isArray(body.gaps) ? body.gaps : null;
+						// An absent or empty `gaps` is "no ranking", never a list of zeroes: the totals line
+						// would otherwise describe a corpus standing behind a ranking that does not exist.
+						setCoverage(ranked && ranked.length ? body : null);
+					})
+					.catch(function () { setCoverage(null); });
+			}, []);
+
 			var rows = [];
 			// The same mark as the plugin-list icon and the sidebar chip: the conversation ring has no icon
 			// channel, so the panel body is the one place the tab can show what it belongs to.
@@ -1301,11 +1504,17 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 			rows.push(h("div", { key: "scope", style: DIM },
 				T("panel.counters")));
 
+			// The strip and the activity line below are the two places a reader meets these counters, and
+			// every word between the numbers is a lookup. Hard-coding it at the call site is what made the
+			// Chinese panel read `0 with a lesson · 0 lessons surfaced · 0 became a lesson` — the numbers
+			// were right and the sentence was English.
 			rows.push(h("div", { key: "strip", style: Object.assign({}, BOX, { marginTop: "8px" }) },
-				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)"));
+				count(searches.length, T("unit.search"), T("unit.searches")) + " · " +
+				T("panel.strip.hitTpl", { count: count(withLesson, T("unit.lesson"), T("unit.lessons")), n: withLesson, unit: T("unit.lessons") }) +
+				T("panel.strip.missTpl", { count: count(noMatch, T("unit.lesson"), T("unit.lessons")), n: noMatch, unit: T("unit.lessons") }) +
+				T("panel.strip.surfacedTpl", { count: count(lessons.length, T("unit.lesson"), T("unit.lessons")), n: lessons.length, unit: T("unit.lessons") }) +
+				count(votes.length, T("unit.vote"), T("unit.votes")) + " " + T("panel.strip.helpfulTpl", { count: count(helpful, T("unit.vote"), T("unit.votes")), n: helpful, unit: T("unit.votes") }) +
+				count(intakes.length, T("unit.report"), T("unit.reports")) + " " + T("panel.strip.convertedTpl", { count: count(converted, T("unit.report"), T("unit.reports")), n: converted, unit: T("unit.reports") })));
 
 			// ① what this session asked
 			//
@@ -1352,9 +1561,47 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 				);
 			}
 
+			/**
+			 * The entry point, which the panel is the first place a person looks for and the last place
+			 * it used to mention.
+			 *
+			 * The real entry is the composer's `/misakanet` source, and the empty states below said only
+			 * what was missing (`panel.asked.none`, `panel.trust.none`). What was checked before settling
+			 * for a hint plus this one button:
+			 *
+			 * * **Prefilling the composer is out of reach.** The draft lives behind
+			 *   `ctx.conversation.input.for(actx).setDraft(text)` — a *session-scoped* service the panel
+			 *   cannot hold: a view occupant is handed props, and the panel's `apply(ctx)` is the client
+			 *   root. Reaching it would mean injecting a service this plugin does not declare, which on a
+			 *   line without it is the dead-button case this file already refuses (see the deferred
+			 *   `sidebarRightTabs` inject). So no prefilled `/misakanet ` and no text that claims one.
+			 * * **Opening the overlay is in reach**, because it is this module's own state: the card
+			 *   registered on `conversation.input.overlay` renders from `overlayOf(sessionId)`, and the
+			 *   panel receives that same session id. `runOverlaySearch(sessionId, "")` is the module's one
+			 *   opener; it starts no request for an empty query and sends nothing — it just puts
+			 *   `overlay.empty` in front of the person, where the instruction now is.
+			 *
+			 * The button is offered only with a session id (the `main` seat gets none): without one there is
+			 * no overlay to open, and a button that cannot do what its label says is worse than the text.
+			 */
+			function openOverlayFromPanel() {
+				if (!sessionId) return;
+				runOverlaySearch(sessionId, "");
+			}
+
+			/** The section's own empty-state sentence, plus the overlay opener when a session can take it. */
+			function entryPointHint(key, message) {
+				return h("div", { key: key, style: DIM },
+					T(message) + " ",
+					sessionId ? h("button", {
+						type: "button", style: BUTTON, title: T("panel.hint.openTitle"),
+						onClick: openOverlayFromPanel,
+					}, T("panel.hint.openLabel")) : null);
+			}
+
 			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 }, T("panel.asked.none")));
+				rows.push(entryPointHint("s1e", "panel.asked.none"));
 			} else {
 				var searchRows = searches.slice().reverse().slice(0, 20).map(function (entry) {
 					var key = "q" + entry.callId + entry.at;
@@ -1458,15 +1705,18 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 			// richer receipt (per-event types, `count`/`queries`/`sources`, its own `evidence`) but it is an
 			// MCP tool, reachable only through the MCP endpoint with a JSON-RPC `tools/call` — and this
 			// browser half is forbidden from making one (acceptance D4: the same endpoint files issues). The
-			// count therefore carries the helpful-vote signal, and the regression citations and cross-node
-			// confirmations the tool also aggregates are **not** rendered. Nothing here is guessed: no field
+			// count therefore carries the helpful-vote signal, and the observed distinct-client retrieval,
+			// the regression citations and the declared-provenance hint the tool also aggregates are **not**
+			// rendered. Nothing here is guessed: no field
 			// this endpoint does not return is displayed.
 			//
-			// The count itself is the same threshold `misakanet_me_events` reports: one helpful vote is a
-			// reuse signal (E3), two or more is E4 — which is also why the rule below is stated once.
+			// The count is the helpful-vote signal only, and since 2026-10-16 a vote is capped below E4 at
+			// every count — no row here can claim the rung, which is also why the rule below is stated once.
+			// (`E4` itself is observed elsewhere: `misakanet_me_events` counts distinct clients from
+			// `search_signals`, which this browser half likewise cannot read.)
 			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 }, T("panel.trust.none")));
+				rows.push(entryPointHint("s3e", "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.
@@ -1476,10 +1726,10 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 					var confirmations = trust[lesson.lessonId];
 					var counted = confirmations === undefined ? T("panel.trust.checking")
 						: (confirmations === null ? T("panel.trust.unavailable")
-							: count(confirmations, T("panel.trust.human")) + (confirmations >= 2 ? " → E4" : ""));
+							: count(confirmations, T("panel.trust.human")));
 					var declared = lesson.evidence || T("panel.trust.noLevel");
 					var external = h("span", { style: DIM },
-						T("panel.trust.external") + counted + (confirmations >= 2 ? " · " + T("panel.trust.e4signal") : ""));
+						T("panel.trust.external") + counted);
 					return h("div", { key: "l" + lesson.lessonId, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
 						h("div", null,
 							h("span", {}, lesson.title || lesson.lessonId),
@@ -1492,12 +1742,16 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 			// ④ your activity, two scopes
 			rows.push(h("div", { key: "s4", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.activity")));
 			rows.push(h("div", { key: "s4r", style: BOX },
-				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.session") + count(searches.length, T("unit.search"), T("unit.searches")) + " · " +
+					T("panel.activity.reusedTpl", { count: count(lessons.length, T("unit.lesson"), T("unit.lessons")), n: lessons.length, unit: T("unit.lessons") }) +
+					count(votes.length, T("unit.vote"), T("unit.votes")) + " · " +
+					T("panel.activity.reportsTpl", { count: count(intakes.length, T("unit.reportFiled"), T("unit.reportsFiled")), n: intakes.length, unit: T("unit.reportsFiled") }) +
+					T("panel.activity.filedTpl", { count: count(converted, T("unit.conversion"), T("unit.conversions")), n: converted, unit: T("unit.conversions") })),
 				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")),
+					T("panel.activity.reusedTpl", { count: count(stats.lessonsReused || 0, T("unit.lesson"), T("unit.lessons")), n: stats.lessonsReused || 0, unit: T("unit.lessons") }) +
+					count(stats.votes || 0, T("unit.vote"), T("unit.votes")) + " · " +
+					T("panel.activity.reportsTpl", { count: count(stats.reportsFiled || 0, T("unit.reportFiled"), T("unit.reportsFiled")), n: stats.reportsFiled || 0, unit: T("unit.reportsFiled") }) +
+					T("panel.activity.filedTpl", { count: count(stats.reportsConverted || 0, T("unit.conversion"), T("unit.conversions")), n: stats.reportsConverted || 0, unit: T("unit.conversions") })),
 				h("div", { style: DIM }, T("panel.activity.scope"))));
 
 			// ⑤ voice
@@ -1522,6 +1776,76 @@ var DEFAULT_MCP_URL = "https://misakanet.org/mcp";
 					: T("panel.voice.none")),
 				h("div", { style: DIM }, T("panel.voice.hook"))));
 
+			// ⑥ the network's most-retrieved lessons
+			//
+			// Read-only, and about the whole network rather than this session: no lesson here had to be
+			// surfaced by the agent first. There is no vote affordance in this section and none of its copy
+			// says the count is approval — the number is an observed retrieval, and the rule states what it
+			// does and does not mean before the first row.
+			rows.push(h("div", { key: "s6", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.hot")));
+			if (hot === undefined) {
+				rows.push(h("div", { key: "s6w", style: DIM }, T("panel.hot.loading")));
+			} else if (hot === null) {
+				// The endpoint ranked nothing (or did not answer). Saying so beats printing five rows of
+				// `0 retrievals`, which would name lessons the payload never ranked.
+				rows.push(h("div", { key: "s6e", style: DIM }, T("panel.hot.none")));
+			} else {
+				rows.push(h("div", { key: "s6rule", style: DIM }, T("panel.hot.rule")));
+				rows.push(h("div", { key: "s6l", style: DIM }, T("panel.hot.limit", { n: HOT_LESSON_LIMIT })));
+				rows.push(h("div", { key: "s6r" }, hot.slice(0, HOT_LESSON_LIMIT).map(function (entry) {
+					var path = String(entry && entry.lesson_id ? entry.lesson_id : "");
+					var times = entry && typeof entry.count === "number" ? entry.count : null;
+					return h("div", { key: "h" + path, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
+						h("span", { style: { fontFamily: "monospace" } }, path),
+						h("span", { style: DIM }, "  · " + (times === null
+							? T("panel.hot.noCount")
+							: count(times, T("unit.retrieval"), T("unit.retrievals")))));
+				})));
+			}
+
+			// ⑦ the topics the corpus cannot answer yet
+			//
+			// Why ⑦ and not ⑥: `main` already numbers the retrieval ranking ⑥ (and owns `key: "s6"` plus the
+			// `panel.hot` keys), so this section takes the next number and the `s7` key rather than sharing
+			// one — two sections with the same React key is a duplicate-key defect, and two sections that
+			// both claim to be ⑥ make the rule lines unreadable. Every key here is `s7*`, and the dictionary
+			// family is `panel.coverage*`, so neither half of that identity is borrowed.
+			//
+			// Read-only, and about the whole network rather than this session: no topic here had to be
+			// searched first. There is no vote affordance in this section and none of its copy says the order
+			// is approval — `unsolved30d` counts unanswered searches, and the rule says what it counts before
+			// the first row and how it differs from the retrieval ranking above.
+			rows.push(h("div", { key: "s7", style: { marginTop: "12px", fontWeight: 600 } }, T("panel.coverage")));
+			if (coverage === undefined) {
+				rows.push(h("div", { key: "s7w", style: DIM }, T("panel.coverage.loading")));
+			} else if (coverage === null) {
+				// The board ranked nothing (or did not answer). Saying so beats printing rows of `0`, which
+				// would name topics the payload never ranked.
+				rows.push(h("div", { key: "s7e", style: DIM }, T("panel.coverage.none")));
+			} else {
+				rows.push(h("div", { key: "s7rule", style: DIM }, T("panel.coverage.rule")));
+				var coverageMetrics = coverage.metrics || {};
+				if (typeof coverageMetrics.publishedLessons === "number") {
+					rows.push(h("div", { key: "s7t", style: DIM },
+						T("panel.coverage.totals", {
+							count: count(coverageMetrics.publishedLessons, T("unit.lesson"), T("unit.lessons")),
+							n: coverageMetrics.publishedLessons, unit: T("unit.lessons"),
+						})));
+				}
+				rows.push(h("div", { key: "s7r" }, coverage.gaps.slice(0, COVERAGE_LIMIT).map(function (gap) {
+					return h("div", { key: "f" + gap.taskFamily, style: { borderTop: "1px solid " + MUTED, padding: "4px 0" } },
+						h("span", {}, gap.taskFamily),
+						h("span", { style: DIM }, "  " + T("panel.coverage.lessonsTpl", {
+							count: count(gap.lessonCount, T("unit.lesson"), T("unit.lessons")),
+							n: gap.lessonCount, unit: T("unit.lessons"),
+						})),
+						h("span", { style: DIM }, T("panel.coverage.unsolvedTpl", {
+							count: count(gap.unsolved30d, T("unit.search"), T("unit.searches")),
+							n: gap.unsolved30d, unit: T("unit.searches"),
+						})));
+				})));
+			}
+
 			rows.push(h("div", { key: "foot", style: Object.assign({}, DIM, { marginTop: "12px" }) },
 				T("panel.footnote")));