magpie-plugin-msmoli 0.2.0 → 0.3.0

package/index.mjs

@@ -1,5 +1,5 @@
-// ModelScope (魔搭) 魔粒 check-in for magpie — one provider per site:
-// modelscope.cn (`msmoli`) and modelscope.ai (`msmoli-intl`).
+// ModelScope credits check-in for magpie — one provider that serves both
+// modelscope.cn and modelscope.ai, each account on the site its token is from.
 //
 // magpie calls auth.checkin once a Beijing day per signed-in account while the
 // provider's check-in switch is on, and again later that day after a failure.
@@ -8,48 +8,71 @@
 // How the claim works: ModelScope's OpenAPI has no check-in endpoint. What it
 // has is a side effect — GET /api/v1/users/login/info counts as a website
 // sign-in, and the server grants that day's credits with it (200 for the
-// "注册并登录" daily grant, 50 for a bound Aliyun account), once per day.
+// "register-and-sign-in" daily grant, 50 for a bound Aliyun account), once per day.
 // modelscope.ai is the same backend with the same paths and the same
 // daily_active rule, but separate accounts and separate tokens: measured, an
 // ms- token authenticates only on the site it came from.
 //
 // The plugin serves no chat models: inference keeps using the API-key modelscope
-// preset in providers.json. Both providers exist only to carry the sign-in the
+// preset in providers.json. This provider exists only to carry the sign-in the
 // check-in runs as.
 
 import { readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { isAbsolute, join } from "node:path"
 
-// A profile is everything that differs between the two deployments: the
-// origin, the provider id (magpie keys the sign-in, the card and the alias by
-// it), and the words on the card. The rest of this module is shared — the two
-// sites answer with the same envelopes, the same magicubes rules and the same
-// 24-hour expiry, so a second copy of the hooks would only be a second place
-// for them to drift.
+// One provider serves both sites: a token's site is a fact about the token,
+// not about the card, so the plugin finds it per account instead of asking the
+// user to pick a provider. A profile carries what differs between the sites —
+// the origin, the plan line the card shows, and the word a 401 uses.
 const CN = {
   site: "https://modelscope.cn",
-  id: "msmoli",
-  name: "ModelScope 魔粒",
   plan: "魔搭社区",
   where: "国内站",
 }
 const INTL = {
   site: "https://modelscope.ai",
-  id: "msmoli-intl",
-  name: "ModelScope 魔粒（国际版）",
   plan: "魔搭社区（国际版）",
   where: "国际站",
 }
+const SITES = [CN, INTL]
+
+// The provider's id and name: one card, whatever mix of accounts it holds.
+const ID = "msmoli"
+const NAME = "ModelScope 魔粒"
+
+// sites remembers which site each token signs in to, for the life of the
+// process. Finding it costs one of the reads the hook was about to make anyway
+// — a 401 is the only answer that rules a site out — and asking again on every
+// poll would double every read. Bounded like `names`: a host is long-lived, and
+// tokens come and go.
+const sites = new Map()
+const SITES_MAX = 64
+const rememberSite = (token, profile) => {
+  sites.delete(token)
+  sites.set(token, profile)
+  while (sites.size > SITES_MAX) sites.delete(sites.keys().next().value)
+}
+
+// profileForSite maps a value kept on a sign-in back to its site. Anything
+// else — an older host's field, a hand-edited file — is ignored and the token
+// probed again rather than trusted.
+const profileForSite = (v) => (typeof v === "string" ? SITES.find((p) => p.site === v) : undefined)
 
 const LOGIN_INFO = "/api/v1/users/login/info"
 const BALANCE = "/openapi/v1/magicubes/balance"
 const TXNS = "/openapi/v1/magicubes/transactions"
 
+// The sign-in is the site's own web session, so every request carries a
+// browser's UA rather than a bare fetch one — a bare UA is the one shape
+// measured to get a different answer. The string is fixed on purpose (the
+// suite pins it whole): it names a browser version rather than pretending to
+// be one, and nothing here fingerprints beyond it.
 const UA =
   "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
 
-// 每日发放的规则。这类魔粒 24 小时过期，不累积。
+// The daily-grant rules. This kind of credits expires in 24 hours; they do not
+// accumulate.
 const DAILY_RULES = ["daily_active", "aliyun_bindlogin"]
 
 const TIMEOUT_MS = 8000
@@ -83,13 +106,22 @@ const USAGE_BUDGET_MS = 18 * 1000
 // rule, one place — tokenOf and unusableKey must agree on it, or a key one of
 // them accepts and the other refuses has no single answer to give the user.
 const SENDABLE = /^[\x21-\x7e]+$/
-const rawKey = (auth) => (auth?.type === "api" ? String(auth.key ?? "").trim() : "")
+// A key that is not a string is not a key: String() on an array or a number
+// turns it into text that passes SENDABLE, and the sign-in's key then goes out
+// as a Cookie — measured, `key: [token]` sent the token and `key: 1234…` sent
+// the number. The host writes a string; anything else is a file this plugin
+// could not read, and it is refused the way an unsendable key is, not sent.
+const rawKey = (auth) => (auth?.type === "api" && typeof auth.key === "string" ? auth.key.trim() : "")
 
 // tokenOf is the key this sign-in carries, or "" when there is none or it is
 // not one we can send. The two are told apart by the caller so a key that is
 // there and unusable does not read as "you never signed in".
 const unusableKey = (auth) => {
-  const key = rawKey(auth)
+  if (auth?.type !== "api" || auth.key === undefined || auth.key === null) return false
+  // a key of the wrong type is a store this plugin cannot read, not an absent
+  // one: reported as unusable so the message says the token is unreadable
+  if (typeof auth.key !== "string") return true
+  const key = auth.key.trim()
   return Boolean(key) && !SENDABLE.test(key)
 }
 const tokenOf = (auth) => {
@@ -133,7 +165,8 @@ const handleOf = (token) => fnv(token).toString(16)
 // magpie's own fetch, behind a proxy, fails in Go's words — a plain Error
 // "proxyconnect tcp: dial tcp 127.0.0.1:7890: i/o timeout" (host.js), not a
 // TypeError — so it is named before the timeout test: its "i/o timeout" is the
-// proxy's dial, and "请求超时（8 秒）" would send the user after the network
+// proxy's dial, and the "request timed out (8 s)" wording would send the user
+// after the network
 // when the proxy is what is down.
 function saidFailure(e, ctl, budget) {
   if (e !== ctl.signal.reason && /^proxyconnect\b/i.test(String(e?.message ?? ""))) {
@@ -142,8 +175,10 @@ function saidFailure(e, ctl, budget) {
   if (e === ctl.signal.reason || /timeout/i.test(String(e?.message ?? ""))) {
     // Ceiling, not round: the budget can be down to a few hundred
     // milliseconds when the hook's own deadline is what cut it short, and
-    // "请求超时（0 秒）" tells the user nothing about which of the two it was.
-    return new Error(`请求超时（${Math.max(1, Math.ceil(budget / 1000))} 秒）`)
+    // "request timed out (0 s)" tells the user nothing about which of the two
+    // it was. The flag is how siteRead tells a timeout (the link, which the
+    // other site would wait out again) from a refusal (that site's answer).
+    return Object.assign(new Error(`请求超时（${Math.max(1, Math.ceil(budget / 1000))} 秒）`), { timeout: true })
   }
   if (e?.name === "TypeError" || /fetch failed/i.test(String(e?.message ?? ""))) {
     return new Error("请求失败：网络不通、被代理拦截，或遇到了重定向")
@@ -151,6 +186,144 @@ function saidFailure(e, ctl, budget) {
   return e
 }
 
+// siteRead is how the plugin learns a token's site: the remembered site is
+// asked first, then the other one. Only a usable answer — a 200 that parses
+// and does not say it failed — chooses a site and is remembered. A 401 drops
+// the memory (another site may hold the token). Every other failure — a
+// transport error, a proxy's 200 page, a 5xx, a 200 whose body denies the
+// token, a 2xx that is not 200 (a 202 means accepted-and-not-done; gate()
+// refuses it too) — moves the probe on to the other site: the remembered
+// site being wrong (a re-keyed token), unreachable, or broken must not strand
+// the account on it, and the domestic site can be broken on a network where
+// the international one works. An API-level refusal (403 risk control, a 400
+// on the request) is final: this site accepted the token and the answer is
+// what the caller must report. A 429 is not that answer — a rate limit is the
+// site's, not the token's — so the probe moves on and keeps it as the
+// fallback, the way it treats a 5xx. The first failure is the one reported
+// when neither site gives a usable answer, because it is the one the user was
+// closest to (their token most often comes from the domestic site).
+// awaitsSignIn: a 401 is the site refusing the token only when its answer
+// reads as such — a bare "unauthorized" in the words ModelScope's login and
+// API layers use, an empty object (the token read, nothing said), or a
+// status-only answer. Anything else is the path answering: a proxy's
+// "proxy authentication required", a gateway's title, an HTML page, some
+// other object with no such word in it. Measured: a proxy's JSON 401 had the
+// card tell the user the sign-in expired, and a re-login would not have
+// changed the answer. A refusal is the default because it is what the site
+// itself sends; the answer has to excuse it to be read as the path's.
+const pathWords = /proxy|gateway|www-authenticate|re-?authenticate|\bbasic\b/i
+// a path naming itself, as a whole word: in the words of a body or in a field
+// name ("proxy": "upstream"). The 401's words and the 403's envelope both ask.
+// an upstream's "Upstream returned status 401" is not a path naming itself: a
+// site reads the body above it, and what a proxy puts there is its own words
+const PATH_MARK = /(?<![a-z])(?:proxy|gateway|re-?authenticate)(?![a-z])/i
+const signInWords = /unauthori[sz]ed|invalid (?:access )?token|token (?:is )?(?:invalid|expired|revoked)|invalid authentication|authorization header|not (?:logged|signed) in|unauthenticated|auth(?:entication)? (?:failed|required)|\b(?:expired|revoked)\b|\b401\b|登录|未登录|失效|过期|令牌|凭证|鉴权|认证/i
+const awaitsSignIn = (body) => {
+  if (body === null || typeof body !== "object") return false
+  // an empty object is a refusal: a site that answers 401 with nothing in it
+  // has refused the token, and both sites refusing is a dead token (pinned by
+  // "a forgotten site is dropped from memory when the other site refuses
+  // too"). A proxy answering 401 with `{}` is indistinguishable from that; the
+  // cost of reading it as a refusal is a re-login prompt, not the token
+  // (a body that only names a path — {"message":"unauthorized","proxy":
+  // "upstream"} — is the path's: its names count as its words, and a field
+  // called "proxy" said "proxy" whatever its value)
+  const keys = Object.keys(body)
+  if (keys.length === 0) return true
+  if (/proxy|gateway/i.test(keys.join(" "))) return false
+  // ModelScope's login layer answers in Pascal case ({"Code":401,"Success":false,
+  // "Message":"…"}), the OpenAPI layer in lower case, and some messages are
+  // Chinese; all of them are read (a numeric or string code of 401 included)
+  // once a body that names a path has been set aside: a proxy's 401 carries a
+  // code of its own, and a code is not evidence about who answered
+  const said = [...keys.flatMap((k) => (typeof body[k] === "string" ? [k, body[k]] : [k])), body.error_description, body.detail, body.Detail, body.title, body.Title]
+    .filter((x) => typeof x === "string")
+    .join(" ")
+  if (pathWords.test(said) || PATH_MARK.test(said)) return false
+  const code = body.code ?? body.Code
+  if (String(code ?? "") === "401") return true
+  return said !== "" && signInWords.test(said)
+}
+async function siteRead(token, path, deadline = Infinity) {
+  const known = sites.get(token)
+  const order = known ? [known, ...SITES.filter((p) => p !== known)] : SITES
+  // A parsed 4xx/429/5xx that is not an answer is still the site *saying
+  // something*, and it beats a transport error from the other site ("risk
+  // control" is more useful than "check your proxy"). It is kept as `answer`
+  // while the loop goes on: the site that gave it may not be the one holding
+  // this token (a stale `site`, a re-keyed sign-in, a middlebox's 404).
+  let answer
+  // `said` is a parsed reply that is not an answer (429, 5xx, a 200 that says
+  // it failed); `down` is a transport error. They are kept apart so the
+  // promise above holds in both directions: whatever the site said beats the
+  // link failing, whichever order the two arrive in. `first` is then always a
+  // parsed reply (or nothing), and the dead link is the last thing reported.
+  let said
+  let down
+  for (const profile of order) {
+    let got
+    try {
+      got = await json(profile.site, token, path, deadline)
+    } catch (e) {
+      // A timeout is the link, not the site, and the remembered site may be
+      // the stale half of a re-keyed sign-in — the same state the 401 branch
+      // exists for. The second read is bounded by the hook's own deadline, so
+      // a dead network costs at most the budget it would have spent anyway;
+      // giving up here left an account on a wrong or unreachable site all day.
+      // a parsed answer from the other site outranks this (see below): the
+      // link being down says nothing about the account
+      down ??= e instanceof Error ? { error: e } : { error: new Error("") }
+      continue
+    }
+    if (got.res.status === 401 && got.parsed && awaitsSignIn(got.body)) {
+      // A 401 where the token was accepted before: the sign-in may have been
+      // re-keyed with a token of the other site, or the remembered site may be
+      // stale (a kept `site` value, a proxy's 200 cached as an answer). A 401
+      // that is not ModelScope's own answer is a middlebox's challenge, not
+      // the token being refused — it falls through like any other non-answer.
+      // Measured: a proxy that answered 401 with its own JSON had the card
+      // tell the user the sign-in expired, and a re-login would not have
+      // changed the answer.
+      // A 401 is not evidence the token is dead by itself: every token answers
+      // 401 on the site it does not belong to, so a stale `site` value or a
+      // re-keyed sign-in looks exactly like a revoked token. The walk's own
+      // end says it (no site answered); this branch only forgets the site and
+      // lets the other one answer.
+      //
+      // A sibling read of the same token may have finished in between: this
+      // one captured its order before the other site was known, and its 401
+      // arrives after the sibling confirmed a site. Deleting then drops that
+      // confirmation — the token reads as unknown for a probe it already paid
+      // for, and an expiry decision can land on a live sign-in. The site is
+      // forgotten only while it is still the one in memory.
+      if (profile === known && sites.get(token) === profile) sites.delete(token)
+      continue
+    }
+    if (got.parsed && got.res.status === 200) {
+      if (okOf(got.body)) {
+        rememberSite(token, profile)
+        return { profile, ...got }
+      }
+      said ??= { answer: { profile, ...got } }
+      continue
+    }
+    // A 4xx is the site answering — but a 404/405/451 from a middlebox, or a
+    // 400/403 from the site that does not hold this token, is no better
+    // evidence than a 5xx. Keep it as the best answer and let the other site
+    // answer too; a genuine risk-control 403 on the right site still ends up
+    // as the report when the other site has nothing better to say.
+    if (got.parsed && got.res.status >= 400 && got.res.status < 500 && got.res.status !== 429) {
+      answer ??= { profile, ...got }
+      continue
+    }
+    said ??= { answer: { profile, ...got } }
+  }
+  if (answer) return answer
+  if (said) return said.answer
+  if (down) throw down.error
+  throw deadToken("任一站点")
+}
+
 async function json(site, token, path, deadline = Infinity) {
   const left = deadline - Date.now()
   if (left <= 0) throw new Error("预算已用完，本次请求未发出")
@@ -165,8 +338,9 @@ async function json(site, token, path, deadline = Infinity) {
     ctl.signal.addEventListener("abort", () => reject(ctl.signal.reason), { once: true })
   })
   aborted.catch(() => {})
+  let res
   try {
-    const res = await Promise.race([
+    res = await Promise.race([
       aborted,
       fetch(site + path, {
         // every redirect is refused, the site's own included: one that left
@@ -189,8 +363,26 @@ async function json(site, token, path, deadline = Infinity) {
     try {
       body = text ? JSON.parse(text) : {}
     } catch {}
-    return { res, body, parsed: body !== null }
+    // an empty body is not an answer at all: a bare 401 from a proxy is the
+    // path, not the site saying the token is refused, and reading it as "{}"
+    // (parsed, an object) signed the account out over a middlebox's refusal
+    return { res, body, parsed: body !== null && (text !== "" || res.status === 200) }
   } catch (e) {
+    // An answer we stopped reading is still live: a declared length over the
+    // cap is refused before a byte is read, and the socket keeps streaming
+    // into a body nobody consumes once the timer is cleared — the plugin has
+    // no hold on the transport at all. Cancel the unconsumed body and abort
+    // the request, so it ends with this call.
+    // The abort does NOT carry e: saidFailure reads "e is the abort reason" as
+    // a timeout, and aborting with "响应过大" would relabel the refusal.
+    if (res) {
+      try {
+        await res.body?.cancel?.()
+      } catch {}
+      try {
+        ctl.abort(new Error("read abandoned"))
+      } catch {}
+    }
     throw saidFailure(e, ctl, budget)
   } finally {
     // the answer is here: the timer has nothing left to guard, and one left
@@ -363,11 +555,13 @@ function cnTime(value) {
   return Number.isFinite(at) ? new Date(at).toISOString() : ""
 }
 
-// ── 签到时段 ──────────────────────────────────────────────────────────────
-// magpie 在北京日切换时问一次，之后每 30 分钟重试一次失败；插件没有自己的
-// 定时器（见 README 的「上游」一节）。所以在还没到今天这个账号的目标时刻
-// 时，只能回答 failed——那是宿主唯一会重试的结果——其余结果都会让当天就此
-// 了结。夜里这一问一答不发出任何请求，领的动作留给上班时段的那一问。
+// ── Check-in window ───────────────────────────────────────────────────────
+// magpie asks once at the Beijing-day rollover and retries a failure every 30
+// minutes; the plugin has no timer of its own (see the README's "upstream"
+// section). So before today's target moment for this account arrives, the only
+// answer is failed — that is the one outcome the host retries; every other
+// outcome ends the day there and then. That overnight ask-and-answer sends no
+// request; the claim itself is left to the ask during working hours.
 const WINDOW_DEFAULT = ["08:30", "10:00"]
 
 // LAST is the latest minute the window's end is capped at. The host asks
@@ -496,7 +690,12 @@ const names = new Map()
 const NAMES_MAX = 64
 
 function rememberName(token, name) {
-  if (!name) return
+  // An empty name is remembered too. "The server gave no usable name" is a
+  // fact as much as a name is: before this, `names` never held it, so the
+  // "claimed and the name is known" shortcut never took and every provisional
+  // re-ask in a morning touched login/info again — the dozen extra sign-ins
+  // the shortcut exists to prevent. A read that failed does not come here, so
+  // a later ask still tries once more.
   names.delete(token)
   names.set(token, name)
   while (names.size > NAMES_MAX) names.delete(names.keys().next().value)
@@ -568,10 +767,6 @@ function aliasOf(id, dir, label) {
   return ""
 }
 
-// rememberAccountName tells magpie the account's own name, so its card reads
-// "Mison" instead of "API key …a1b2". The sign-in is written as it already
-// is — the same key, no second copy of the token — with the name beside it;
-// an account that has one already is left alone.
 // maskToken hides all but the ends of a token, for messages that mention one.
 // The log is magpie's own, but a token has no business in it whole.
 const maskToken = (token) =>
@@ -595,23 +790,61 @@ const maskToken = (token) =>
 // matched is a piece of the real key, not a shape, so a key broken across two
 // lines is still the key, and masking it whole is the point.
 //
-// The matching runs over the visible characters alone, in one pass. Stepping
-// over a character as the scan went — and restarting one position later when
-// the run came up short — made a run of them cost its own length at every
-// position it contained: a 256 KiB body of newlines (a proxy's page, or a
-// server echoing one) took minutes, inside a hook whose whole budget is 25
-// seconds, and the plugin host's event loop with it. Collected first, the
+// The matching runs over the alphanumeric characters alone, in one pass, and
+// against the token's own alphanumeric run. Collecting "the characters the
+// token is made of" instead let a character the token genuinely holds — the
+// "-" of every ms- key — be used as a cutter: a server echoing the key with a
+// "-" every 11 characters produced runs that were each under MIN_ECHO, and
+// the whole key reached the card. Punctuation is now a separator whether the
+// token holds it or not, and only its letters and digits say "this is the
+// key". Everything else — whitespace, a zero-width space, a comma, a middle
+// dot, an emoji, or the key's own hyphen — is stepped over and the pieces on
+// either side joined for the comparison. Skipping them is what keeps an echo
+// broken into short chunks whole, and a chunk under MIN_ECHO from surviving
+// on its own. A whitelist of separators cannot do this: the set is open, and
+// the one character it misses is the one the server uses.
+//
+// Stepping over a character as the scan went — and restarting one position
+// later when the run came up short — made a run of them cost its own length
+// at every position it contained: a 256 KiB body of newlines (a proxy's page,
+// or a server echoing one) took minutes, inside a hook whose whole budget is
+// 25 seconds, and the plugin host's event loop with it. Collected first, the
 // same text is scanned once and the spans are put back where they were.
-const MIN_ECHO = 12
+// MIN_ECHO is how much of the key must sit together before the text is taken
+// for an echo. Ten rather than twelve, so that "a piece of at least 11
+// characters of the key" is masked: with the scan starting one character past
+// a short run (see maskEchoes below), a floor of 12 missed a run of 11 that
+// opened a chunked echo. Ten still leaves an ordinary short word ("ms-dos",
+// an 8-character slice) alone. The final review then showed the echo split
+// into 8-character groups joined by one letter: each group is under this
+// floor, so the mask steps over a single filler inside a run instead of
+// restarting, and the floor applies to the joined run.
+const MIN_ECHO = 10
+// fold is the form an echo is compared in: NFKC (a full-width "ｍｓ" is the
+// same key typed on another keyboard), lower case (a server that upper-cases
+// its log is still echoing the key), and letters and digits only (everything
+// else is a separator the echo inserted). Case and compatibility are not a
+// change of secret, and comparing byte for byte left the whole key on the
+// card when either changed.
+const fold = (s) => (typeof s === "string" ? s.normalize("NFKC").toLowerCase().replace(/[^a-z0-9]/g, "") : "")
 const maskEchoes = (s, token) => {
-  if (typeof token !== "string" || token.length < MIN_ECHO) return s
+  if (typeof token !== "string") return s
+  const flat = fold(token)
+  if (flat.length < MIN_ECHO) return s
+  // at/end are the source text's bounds for each folded character. One source
+  // code point can fold into more than one ("fi" is "fi"), so the end is kept
+  // per entry rather than derived from the folded length.
   const vis = []
   const at = []
+  const end = []
   for (let i = 0; i < s.length; ) {
     const c = String.fromCodePoint(s.codePointAt(i))
-    if (!invisible(c)) {
-      vis.push(c)
-      at.push(i)
+    for (const f of c.normalize("NFKC").toLowerCase()) {
+      if (f >= "a" && f <= "z" || f >= "0" && f <= "9") {
+        vis.push(f)
+        at.push(i)
+        end.push(i + c.length)
+      }
     }
     i += c.length
   }
@@ -620,31 +853,68 @@ const maskEchoes = (s, token) => {
   for (let k = 0; k < vis.length; ) {
     let piece = ""
     let v = k
-    while (v < vis.length && token.includes(piece + vis[v])) {
-      piece += vis[v]
-      v++
+    let fillers = 0
+    while (v < vis.length) {
+      if (flat.includes(piece + vis[v])) {
+        piece += vis[v]
+        v++
+        continue
+      }
+      // Characters the token does not hold at this point, between two pieces
+      // of it: a server that prints "01234567x 89abcde0x …" writes
+      // 8-character pieces under MIN_ECHO and a letter between them, and the
+      // pieces together are the key. Up to as many characters as the run has
+      // already matched are stepped over — an echo is mostly the key — and the
+      // run resumes at the first of them that continues it. A filler may only
+      // be stepped over *inside* a run: skipping a leading character before
+      // anything matched swallowed the word in front of the key ("x ms-…" lost
+      // its x). One filler was the first cut; two in a row then went through
+      // ("01234567xx 89abcdefxx …" kept the whole body).
+      if (piece.length === 0) break
+      const stop = Math.min(vis.length, v + 1 + (piece.length - fillers))
+      let hit = -1
+      for (let j = v + 1; j < stop; j += 1) if (flat.includes(piece + vis[j])) { hit = j; break }
+      // one character is stepped over however little has matched (a server's
+      // single letter between pieces); more than one only when the run is
+      // already long enough to be an echo under the lower floor. Without that
+      // second half, "said: aaaa1111-b" matched the last s of "said" and then
+      // skipped "id" to join the piece, and a 9-character slice that the floor
+      // is meant to leave alone was masked as if it were longer.
+      if (hit < 0 || (hit - v > 1 && piece.length < MIN_ECHO - 2)) break
+      fillers += hit - v
+      v = hit
     }
+    // The floor counts the key's own characters, not the characters the echo
+    // wrote them in: a slice carrying its own hyphens ("1-bbbb-2222-") is
+    // twelve characters on the card and nine of the key, and nine is under the
+    // floor by design — a fragment that short is not the key, and counting
+    // punctuation would mask ordinary hyphenated text ("2026-11-08" is eight
+    // of them). The README says so.
     if (piece.length >= MIN_ECHO) {
-      // the span of the whole run, invisible characters inside it included,
-      // and the ones between it and the last character written before it
+      // The span of the whole run, the characters skipped between its pieces
+      // included. What sat between the last character written and the run's
+      // first one — whitespace skipped while matching — is written out first,
+      // so masking does not join two words that the echo had apart.
+      out += s.slice(from, at[k])
       out += maskToken(token)
-      from = at[v - 1] + vis[v - 1].length
+      from = end[v - 1]
       k = v
     } else {
-      out += s.slice(from, at[k] + vis[k].length)
-      from = at[k] + vis[k].length
+      out += s.slice(from, end[k])
+      from = end[k]
       k++
     }
   }
   return out + s.slice(from)
 }
 
-// invisible is a control or format character: what a token pasted out of a
-// chat client carries, and what an echo may have added inside one. INV is the
-// same class for the shape test, less the line breaks: a shape is all that is
-// known there, and run on across a line it would mask the next line's words.
-const invisible = (c) => /[\p{Cc}\p{Cf}]/u.test(c)
+// INV is the control or format class for the shape test, less the line breaks:
+// a shape is all that is known there, and run on across a line it would mask
+// the next line's words. maskEchoes no longer needs a separate predicate —
+// it keeps the alphanumeric characters and skips everything else.
 const INV = String.raw`(?:(?![\n\r])[\p{Cc}\p{Cf}])`
+// the one place a token-shaped run is turned into a mask is maskShaped, below:
+// the shape alone found a run; the body it carries is what decides.
 
 // A key of another shape with an invisible character inside it reaches the card
 // as two words once that character is turned into a space, and neither half
@@ -665,7 +935,547 @@ const GLUE = new RegExp(String.raw`(?<=[A-Za-z0-9+\/=_.-])${INV}(?=[A-Za-z0-9+\/
 // the key, that is known here; the length floor keeps a short "ms-" word
 // ("ms-dos") out of it. An invisible character between two of its characters
 // does not end the run, for the reason maskEchoes steps over one.
-const tokenShaped = new RegExp(String.raw`m${INV}*s${INV}*-(?:${INV}*[\x21-\x7e]){11,}`, "gu")
+//
+// A key pasted with one space inside it ("ms-aaaa1111 bbbb-2222-…") is the
+// same key, and each half is under every word floor on its own: that is the
+// second arm, six characters, one space, five more. "ms-dos and ms-word" has
+// no such shape (six and five characters either side of its real spaces).
+// The body has to read as key material, not merely be eleven characters:
+// an ordinary word after the front ("The ms-interviewing feature is
+// unavailable" on the card, a nickname of the same) was masked whole and the
+// nickname refused its write-back. A ModelScope key is hex or base64 with a
+// digit in it, nearly always in hyphen-separated groups (aaaa1111-bbbb-2222-
+// cccc-…); a word carries no digit and a version carries its digits as one
+// dotted group ("ms-office 2016", "ms-cli 2026.11.9"). Either spelling does:
+// 11+ that are all hex, or 11+ that carry a digit, and the body's last
+// character joined to a letter or digit is a cut, not the end of a key
+// ("ms-abc12345678abc" is one body, not "…5678" and "abc").
+//
+// A key cut by a space or a line break is still one key, and the two arms
+// above each stopped at the first piece: "ms-vqmjh-75qa-651i -9x8x-2p4r-8t2n-
+// qw7z" was masked to "ms-v…651i" with the rest of the key printed after it,
+// and a key wrapped at a line break ("ms-vqmjh-75qa\n-651i-…") was not seen at
+// all. The third arm reads on past a cut — a run of whitespace (a line break
+// included) or a middot, then a piece that carries a digit — because the pieces
+// of a cut are short and a key's own carry digits. It stops at a word of the
+// text's ("… for provider"), at a version's dotted group ("ms-cli 2026.11.9",
+// "ms-office 2016"), and at anything else that is not a piece. What is masked
+// is still the run maskShaped was handed: the arm widens the shape, and keyBody
+// decides, so text that does not read as a key is returned as written.
+const keyChar = String.raw`(?:${INV}*[\x21-\x7e])`
+const tokenShaped = new RegExp(
+  String.raw`m${INV}*s${INV}*-(?:${keyChar}{11,}|${keyChar}{0,}\s+(?=[\x21-\x7e]*\d)(?![\x21-\x7e]*\.)${keyChar}{5,})` +
+    String.raw`(?:(?:\s*[·•∙‧・⋅]\s*|\s+)(?!(?:m${INV}*s${INV}*-))(?![\x21-\x7e]*\.)(?=[\x21-\x7e]{5,})(?=[\x21-\x7e]*\d)[\x21-\x7e]+)*`,
+  "gu",
+)
+const keyBody = new RegExp(String.raw`(?:[0-9a-f]{11,}(?![0-9a-z])|(?=[\x21-\x7e]{11,})(?!\w)[\x21-\x7e]*\d)`)
+// maskShaped is the replace both passes share: the shape finds a run that
+// begins like a key; keyBody asks whether the run after the front reads as
+// one. A run that does not is ordinary text and is handed back as written,
+// untouched — the caller's own passes then judge it word by word.
+const maskShaped = (m) => (keyBody.test(m) ? maskToken(m) : m)
+// The vendor prefixes whose keys are not distinguishable from a name by its
+// characters alone: the prefix is the evidence ("sk-" is Anthropic and OpenAI's,
+// "sk_live_" Stripe's, "ghp_" GitHub's, "xoxb-" Slack's, "AKIA" AWS'). The body
+// behind it is not asked — a name that starts with one of these is a key first.
+// (a key can be echoed upper-cased — "SK-ANT-API03-…" — and that is the same
+// key; the letters are compared without case)
+const VENDOR = /^(?:sk-|sk_(?:live|test)_|gh[pousr]_|xox[abposr]-|akia|asia|aida|aliyun|ssh-rsa|-----begin)/i
+const keyAt = (word, letters) => isKeyWord(word, letters) || VENDOR.test(word) || /^ms-/i.test(word)
+// maskSpaced is the other reading of a piece of text: a key cut by whitespace
+// is read as one key. Measured without it: a 40-character ghp_ token cut into
+// four went out whole, a foreign ms- key cut the same way, and each piece
+// cleared the word floors on its own. The check gets both readings — maskKeys
+// per word, and this per run — and text that reads as a key under either is
+// masked.
+//
+// Three readings, the same shapes bin/sync.mjs's maskCut reads: a run of words
+// on one line (the body of a key cut by spaces — the key-shaped word at an
+// end of it is where the mask begins, its pieces short or a vendor front); a
+// pair either side of a line break (the break a wrapped copy leaves), judged
+// joined; a narrow run of words that are all short pieces (a key written one
+// character per word). A word already carrying a mask is not judged again.
+const MASKED = "…"
+// the length at which a run is long enough to be a key: the floor every
+// reading asks for, and all a mask needs to show
+const RUNCUT = 20
+// a middot or a bullet, one or two in a row, with at most one space on
+// either side: a cut's other spelling, and the separator a display draws
+// (the dot operator is a display's cut too: "1⋅0⋅0" is "100" spaced out)
+const MIDDOT_GAP = /^(?:[ \t\u00a0\u3000]?[·•∙‧・⋅]){1,2}[ \t\u00a0\u3000]?$/
+const MIDDOT_ONLY = /^[ \t\u00a0\u3000]?[·•∙‧・⋅][ \t\u00a0\u3000]?$/
+// a capitalised word ("Qwen3-Max") is a caption, not a piece of a key: two of
+// them either side of a middot are a list ("Qwen3-Max · Qwen3-Coder")
+const caption = (w) => /^[A-Z][a-z]{2,}/.test(w)
+// wordLike: a word a person wrote — letters only, a lower-case letter and a
+// vowel ("release", "today"). The pieces of a cut usually are not ("AKIA",
+// "qmjh", "ghp_", "NickName=[AKIA"), and a middot with a word on both sides
+// is the card's own separator
+const wordLike = (w) => /^[A-Za-z]+$/.test(w) && /[a-z]/.test(w) && /[aeiouy]/i.test(w)
+// the letters and digits a word ends with: a key can follow a frame
+// ("NickName=[AKIAIOSFODNN")
+const tailOf = (w) => w.match(/[A-Za-z0-9]+$/)?.[0] ?? ""
+// the same for a key-shaped head: "ms-" begins the key and a key may begin
+// with its front
+// the word's own key material: from a vendor front anywhere in it ("(ghp_1234",
+// "key=sk-ant-…"), or its last letters and digits. A front carries an
+// underscore or a hyphen, and a bare tail would cut "ghp_1234AbCd" at the
+// underscore, keeping what the front does not
+const FRONT_IN = /(?:sk-|sk_(?:live|test)_|gh[pousr]_|xox[abposr]-|ms-|akia|asia|aida)[\x21-\x7e]*$/i
+const keyFrontOf = (w) => (VENDOR.test(w) || /^ms-/i.test(w) ? w : w.match(FRONT_IN)?.[0] ?? tailOf(w))
+// a bare vendor stem cut off its punctuation ("ms", "sk", "ghp"): the key's
+// front, with the rest of the front in the next piece ("ms -vqmjh…")
+const STEM = /^(?:ms|sk|gh[opusr]|xox[a-z]?|akia|asia|aida)$/i
+// (a piece of a front — "gh" of "ghp_", "xo" of "xoxb-" — opens a key cut a
+// piece at a time: a word of prose it is not)
+const FRONT_PART = /^(?:sk|gh|ghp|gho|ghs|ghu|ghr|ms|xox|xoxa|xoxb|xoxp|xoxo|xoxr|xoxs|aki|akia|asi|asia|aid|aida)$/i
+const startProse = (w) => /^[a-z]{2,}$/.test(w) && !VENDOR.test(w) && !/^ms-/.test(w) && !STEM.test(w) && !FRONT_PART.test(w)
+function maskSpaced(s, letters) {
+  if (s.length > 32 * 1024) return s
+  const words = [...s.matchAll(/[\x21-\x7e]+/g)]
+  if (words.length < 2) return s
+  const at = (i) => words[i].index
+  const end = (i) => words[i].index + words[i][0].length
+  const gap = (i) => s.slice(end(i - 1), at(i))
+  // (each gap judged once: a page of "1·1·1…" asked the same gap of three
+  // readings at every word, and read itself to its square. Each reading keeps
+  // its own table: one shared table answered a middot test with the space
+  // test's result at the same index, and a space-joined key read as no run)
+  const memo = (fn) => {
+    const mem = new Map()
+    return (i) => {
+      let v = mem.get(i)
+      if (v === undefined) mem.set(i, (v = fn(i)))
+      return v
+    }
+  }
+  const midOf = memo((i) => MIDDOT_GAP.test(gap(i)))
+  const onlyMid = memo((i) => MIDDOT_ONLY.test(gap(i)))
+  const sp = memo((i) => spaces(gap(i)))
+  const front = (w) => VENDOR.test(w) || /^ms-/i.test(w)
+  // a gap a run is read across: one space, a no-break or ideographic one, a
+  // line break, or a middot or a bullet (one or two, with at most one space
+  // each side). The middot is a cut's other spelling as well as a display's
+  // own separator; which one it is, is decided by the words on either side —
+  // a key's front or a piece that does not read as a word is key material, a
+  // word on both sides is prose ("release · notes"), and the cut still has to
+  // be key-shaped below
+  const spaces = (g) => /^[ \t 　\r\n]+$/.test(g) && g.length <= 2
+  // a capitalised word ("Qwen3-Max") is a caption, not a piece of a key: two of
+  // them either side of a middot are a list ("Qwen3-Max · Qwen3-Coder"), which
+  // the card drew as one key before this
+  const partsCut = (k, i) => midOf(k) && (front(words[i][0]) || /^[0-9a-f]{12,}/i.test(words[i][0]) || !wordLike(words[i][0]) || !wordLike(words[k][0]))
+  // (a middot joined to the head's own front is a cut from the first piece:
+  // "Ghp_Abcd1234·Efgh5678" is one key, whatever its pieces would read as
+  // alone; the separator is a cut's for a front, not the card's)
+  const runGap = (k, i) => sp(k) || partsCut(k, i) || (k === i + 1 && midOf(k) && front(words[i][0]))
+  const out = []
+  let from = 0
+  for (let i = 0; i < words.length; i += 1) {
+    if (i > 0 && /^\r?\n$/.test(gap(i)) && end(i) - at(i - 1) >= 20) {
+      const pair = words[i - 1][0] + words[i][0]
+      if (!pair.includes(MASKED) && isKeyWord(pair, letters)) {
+        out.push(s.slice(from, at(i - 1)), maskToken(pair))
+        from = end(i)
+        i += 1
+        continue
+      }
+    }
+    // a character cut: every piece one character ("A K I A …"), or a vendor
+    // front cut in two and then one character at a time ("G H P _ 1 2 …").
+    const w1 = words[i][0]
+    const cutGap = (k) => midOf(k) || sp(k)
+    // (a piece behind a frame — the "(ghp" of "(ghp·_·1·…" — is a piece too)
+    const w1p = w1.replace(/^[^A-Za-z0-9]+/, "")
+    const pieceGap = (k) => (cutGap(k) || onlyMid(k)) && words[k][0].length === 1
+    const pieceHead = /^[A-Za-z_]{1,3}$/.test(w1p) || front(keyFrontOf(w1))
+    if (w1.length === 1 || (pieceHead && i + 1 < words.length && pieceGap(i + 1))) {
+      let k = i
+      while (k + 1 < words.length && k - i <= 96 && pieceGap(k + 1)) k += 1
+      const joined = w1p + words.slice(i + 1, k + 1).map((w) => w[0]).join("")
+      const capJoined = joined.replace(/[^A-Z0-9]/g, "")
+      const rhythmic = /[A-Z][0-9]/.test(capJoined) || /[0-9][A-Z]/.test(capJoined)
+      if (
+        k > i &&
+        // (a front that opens the run is the key's first piece, and a run of
+        // one piece after it is the text's "· 4": the cut has two pieces more)
+        (w1.length === 1 || k - i >= 2 || !front(keyFrontOf(w1))) &&
+        joined.length >= 20 &&
+        (isKeyWord(joined, letters) || (joined.match(/[A-Za-z0-9]+/g) ?? []).some((r) => keyRun(r, letters))) &&
+        (!/^[A-Z0-9]+$/.test(joined) || rhythmic || /^AKIA[0-9A-Z]{16}$/.test(joined))
+      ) {
+        out.push(s.slice(from, at(i)), maskToken(joined.replace(/[·•∙‧・⋅]/g, "")))
+        from = end(k)
+        i = k
+        continue
+      }
+    }
+    // (a front behind a frame — "key=ghp_…", "(ghp_…" — is a word's start,
+    // not a word of prose: the frame itself is the punctuation before it)
+    const framedFront = /^[^A-Za-z0-9]+(?:sk-|sk_[a-z]+_|gh[pousr]_|xox[abposr]-|ms-|akia|asia|aida)/i.test(words[i][0])
+    if (startProse(words[i][0]) && !framedFront) continue
+    // two key-shaped words are two keys, and each is masked where it stands —
+    // unless the two joined are one key cut once ("ghp_…EfG h9012…")
+    // a ModelScope-fronted head followed by a short piece is not a pair: one
+    // is the other's own body, and the run reads them as one key
+    const msPair = /^ms-/i.test(words[i][0]) && !/^ms-[\x21-\x7e]{11,}$/i.test(words[i][0]) && i + 1 < words.length && words[i + 1][0].length <= 16
+    // (two key-shaped pieces joined by a middot are one key's cut — "9f8e7d6c…
+    // 7d6c·5b4a…" — and only two joined by a space are two keys)
+    const pairOfKeys =
+      i + 1 < words.length &&
+      !msPair &&
+      /^[ \t\u00a0\u3000]+$/.test(gap(i + 1)) &&
+      keyAt(words[i][0], letters) &&
+      keyAt(words[i + 1][0], letters) &&
+      !(front(words[i][0]) && isKeyWord(words[i][0] + words[i + 1][0], letters))
+    let j = i
+    let last = i
+    // the last word the run read into its body: a piece read to keep a key in
+    // view is the key's ("…·789·0" lost its last "0"), while a word the run
+    // stopped at is not
+    let readTo = i
+    let mixedCase = words[i][0].length >= 3 && /[a-z]/.test(words[i][0]) && /[A-Z]/.test(words[i][0])
+    let body = words[i][0]
+    let pieces = [body]
+    let shapedBody = false
+    // (a run of middots reads on to its cap, and whether a key is there is
+    // asked of the body only once its length is a key's: a page of "1·1·1…"
+    // answered it at every piece, and read itself to its square)
+    let askedAt = 0
+    let midKey = false
+    // the run's pieces checked as they are read: every piece short enough or a
+    // front, and none a word of seven or more letters (wordPieces)
+    let okPieces = true
+    let wordPieces = false
+    // (a run of capitals and digits that reads as a key after one of its words
+    // is read whatever it goes on to read: "A A A …" is a page, not a key cut
+    // to its cap, and reading it on was a page of the card's budget)
+    let found = false
+    // a front written the way fronts are ("ghp_", "sk-", "ms-"): an upper-
+    // cased vendor id ("AKIA…") is the key itself, and the words after it are
+    // the text's — the prose rule below reads them as prose
+    // (a middot-joined run is a key cut when the run reads as one whole:
+    // "Ghp_Abcd1234·Efgh5678" is one, "file1 · file2 · …" is a list. A run
+    // that is not one is read piece by piece from its head.)
+    const joinedCut = (() => {
+      let t = words[i][0]
+      for (let q = i + 1; q < words.length && t.length < 64; q += 1) {
+        if (!midOf(q) || words[q][0].length > 16) break
+        t += words[q][0]
+      }
+      return t
+    })()
+    // (only a middot-joined run is asked: a whitespace run's "whole" reading is
+    // the cut loop's own, piece by piece)
+    const wholeRun = i + 1 < words.length && midOf(i + 1) && isKeyWord(joinedCut, letters)
+    const headFront = wholeRun || front(keyFrontOf(words[i][0])) || STEM.test(words[i][0])
+    // (a run built of capitals and digits alone is read on only while it is no
+    // key yet: a page of "A A A …" reads as one key's shape at every length)
+    // (a run of one- and two-character capitals — "A A A …", a page of them —
+    // is read on: there is no word of it to end the run, and reading every
+    // one of them was a page of the card's budget)
+    // (a head of capitals and digits alone, the first word too: a vendor id
+    // is read to its front's end, and a page of short words is not one)
+    // (a head that is a vendor front, the first word too, or that carries a
+    // digit: a key's pieces after a front are its own)
+    let capsy = (headFront || /[0-9]/.test(body)) && /^[A-Z0-9]{1,2}$/.test(body)
+    let tinyCaps = capsy
+    for (let k = i + 1; !pairOfKeys && k < words.length && k - i <= 48 && runGap(k, i); k += 1) {
+      last = k
+      // a run already long enough to be a key is not extended on a guess: 20
+      // characters of key material is the floor every reading below asks for.
+      // Once a cut is found the run does go on, because the key does — the
+      // mask has to cover all of a 32-character digest, not its first 20 —
+      // and it stops at a hard cap so a long run of tiny words stays linear
+      if (body.length >= 96) break
+      // (a run that has already read as a key goes on to its cap only over
+      // the separator it read it with: a space-joined run that read as one key
+      // is read on — "ms-abcd… efgh …" is one key cut by spaces — and a page
+      // of "A A A …" is let go)
+      // (the tiny-capitals cap is the one below, at each piece read: asking it
+      // here as well only made the page of "A A A \u2026" end one piece sooner)
+      if (found && !midOf(k) && !/^[ \t\u00a0\u3000]+$/.test(gap(k))) break
+      const x = words[k][0]
+      // a lone hyphen is a cut of its own ("ms - 0123"), not a break
+      if (!/[A-Za-z0-9]/.test(x) && x !== "-") break
+      const mid = midOf(k)
+      // the card's own separator ("Qwen3-Max · Qwen3-Coder") joins a list, not
+      // pieces of one key: a key cut by middots is a key whose pieces are not
+      // captions. A caption piece is read as its own text.
+      // (a head that carries a key's front behind a frame — "NickName=[ghp_…"
+      // — begins with a capital and a lower-case run like a caption's, and is
+      // not one: the run is the key's, and ending it here left the front and
+      // its first piece on the card)
+      if (
+        mid &&
+        caption(x) &&
+        caption(words[i][0]) &&
+        !front(words[i][0]) &&
+        !front(keyFrontOf(words[i][0])) &&
+        !/^[0-9a-f]{12,}/i.test(words[i][0])
+      )
+        break
+      mixedCase = mixedCase || (x.length >= 3 && /[a-z]/.test(x) && /[A-Z]/.test(x))
+      // the readings below ask for a digit or a mixed-case word in the run, and
+      // the key's own front decides the rest: a word of four or more lower-case
+      // letters is prose ("sk-User joined the team") unless the run starts at a
+      // key's front; a word of one to three is key material only while the run
+      // has not yet read as a key ("ms-0123… for provider" keeps its frame)
+      // a word of the run's own frame ("see … here", "the key … here"): four
+      // letters or more, and nothing else — a word carrying digits or
+      // capitals is key material, or a model's name ("Qwen3-Coder")
+      // the run starts at a key's front written the way fronts are ("ghp_",
+      // "sk-", "ms-"): an upper-cased vendor id ("AKIA…") is the key itself
+      const frontHead = (VENDOR.test(words[i][0]) || /^ms-/i.test(words[i][0])) && /^[a-z]/.test(words[i][0])
+      // (a piece of exactly four is a piece of a key cut into fours when the
+      // run started at a front — "ms-vqmjh 75qa 651i …")
+      // a word carrying a lower-case letter and nothing else is prose, wherever
+      // the run started ("sk-User joined the team", "ms-foreign-… here"); a
+      // piece of a key carries digits or is written in capitals, and a piece
+      // of exactly four is a piece of a key cut into fours ("ms-v qmjh 75qa …")
+      // (four letters that a key piece follows are a piece of that key:
+      // "ms-v qmjh 75qa …" — the piece after it carries a digit or a capital)
+      const moreKey = k + 1 < words.length && /[0-9A-Z]/.test(words[k + 1][0])
+      // (a middot's pieces are read whatever they would read as alone: the
+      // separator is a cut's, and "sk-a·nt-a·pi03" is a key)
+      const prose = !mid && /^[a-z]{4,}$/.test(x) && (x.length > 4 || !frontHead || !moreKey)
+      const fronty = front(keyFrontOf(x)) || STEM.test(x)
+      // a word of the run's own text ends it once a cut has been read ("see
+      // AKIA… here", "ms-foreign-… for provider"), and before that if the run
+      // starts at a key's front
+      if (prose && (headFront || j > i)) break
+      const reads = headFront || fronty
+      if (j > i && !reads && !/[0-9A-Z]/.test(x) && !mid && !(body.length >= 24 && !/^[a-z]{1,3}$/.test(x))) break
+      if (!headFront && prose && (x.length > 4 || !fronty)) break
+      // a key that has already read as one ends at a short word ("ms-0123…
+      // for provider" keeps its frame): the frame is not part of the mask
+      // a short word after a run that already reads as a key ends it ("123e…-…
+      // not found", "ms-0123 for provider")
+      if (/^[a-z]{1,3}$/.test(x) && (j > i || isKeyWord(body, letters))) break
+      // (a middot's pieces are the key's: "9f8e·7d6c·…" is one key whatever
+      // case its pieces are written in, and the run goes on to its end)
+      if (j === i && body.length >= 4 * RUNCUT) break
+      // a word of four or more lower-case letters inside the run is prose
+      // ("sk-User joined the team"), not a piece of a key. A run of exactly
+      // four is a piece as readily as a word ("ms-v qmjh 75qa …" is a key cut
+      // into fours), so it ends the run only when the run does not start at a
+      // key's front
+      if (x.length >= 4 && /^[a-z]{4,}$/.test(x) && !/\d/.test(body) && !mid && (x.length > 4 || !frontHead)) break
+      body += x
+      pieces.push(x)
+      readTo = k
+      if (!(x.length <= 16 || front(x) || (x.length <= 64 && /\d/.test(x) && /[A-Za-z]/.test(x)) || tailOf(x) !== x)) okPieces = false
+      // (a run of capitals and digits alone can be a key at any length, and is
+      // read on: it is the one run that has no digit or case to go on)
+      if (/^[A-Za-z]{7,}$/.test(x) && !/^[A-Z]+$/.test(x)) wordPieces = true
+      // (a word of three or more capitals and digits alone is the key's own
+      // piece: "AKIAIOSFODNN" — a page of "A A A …" has none, and a key
+      // written without spaces keeps them)
+      if (x.length >= 3 && /^[A-Z0-9]+$/.test(x) && /[A-Z][0-9]|[0-9][A-Z]/.test(body + x)) found = true
+      capsy = capsy && /^[A-Z0-9]{1,2}$/.test(x)
+      // (a page of "A A A …" reads as one key at every length, and is let go
+      // after sixteen pieces — no key is cut into that many single capitals)
+      if (capsy) tinyCaps += 1
+      if (capsy && tinyCaps > 16) break
+      // a ModelScope key written down before it was cut: its eleven
+      // characters follow ms- at once, and the cut pieces are then read to
+      // the end ("ms-vqmjh75qa 651i 9x8x …") however long the head is
+      shapedBody = shapedBody || (headFront && letters && /^ms-\w{11}/i.test(body) && !/[\s\u3000]/.test(x))
+      // a piece of seven or more letters on its own is a word, not a piece of
+      // a key, and a run holding one is text ("Rebecca Deborah Bradford" is
+      // mixed case and long enough to read as a key otherwise). A piece of 17
+      // a ModelScope-shaped body ("ms-" and eleven characters) is a key the
+      // moment it reads as one; the platform's own keys are shorter than the
+      // twenty characters the other shapes need
+      shapedBody =
+        shapedBody ||
+        headFront &&
+        letters &&
+        /^ms-/i.test(body) &&
+        /\d/.test(body) &&
+        body.length >= 14 &&
+        !pieces.some((w) => /^[a-z]{1,3}$/.test(w))
+      // (the pieces' join is the body: asked once here, not joined again for
+      // every middot piece, which read a page of tiny pieces to its square)
+      // (each piece's check is made when it is read — "okPieces" — so a body
+      // that is no key of key length costs no second walk over its pieces)
+      const bodyKey = body.length < 40 && isKeyWord(body, letters)
+      const cut =
+        (body.length >= 20 || shapedBody) &&
+        !body.includes(MASKED) &&
+        okPieces &&
+        // a piece of seven or more letters is a word, unless it is written in
+        // capitals: a vendor key's piece is ("AKIAIOSFOD · NN7EXAMPLE")
+        // (a middot's piece is the key's whatever it reads as alone: a list of
+        // words with numerals ("file1 · file2 · …") still has to read as one
+        // key whole once its middots are read as spaces, and does not)
+        !wordPieces &&
+        !(mid && !bodyKey) &&
+        (bodyKey || (body.match(/[A-Za-z0-9]+/g) ?? []).some((r) => keyRun(r, letters)))
+      // an all-capitals run follows the same rule as the capitals reading
+      if (cut) {
+        const capRun = body
+        if (!(/^[A-Z0-9]+$/.test(capRun) && !/^AKIA[0-9A-Z]{16}$/.test(capRun) && !/[A-Z][0-9]/.test(capRun) && !/[0-9][A-Z]/.test(capRun))) j = k
+      }
+      // a cut marked by a middot every few characters is a cut, and it goes on
+      // to its cap ("ghp_12·34A·bC…" is a key the display drew a piece per
+      // middot). It is the run's from its first piece when the head is a
+      // key's front ("Ghp_Abcd1234·…": an upper-cased front is one too) — a
+      // piece that does not read as a key on its own is still the key's —
+      // and only from the cut it found otherwise ("…·p789": the pieces before
+      // it are the text's, and the run there reads as one key before the
+      // middot)
+      // (the key begins at the head, as it does for a front, whatever the
+      // middot did with the rest; the run still has to read as one key whole
+      // once its middots are read as spaces — "file1 · file2 · …" is a list)
+      // (a run of middots reads on to its cap. Without a front of its own, it
+      // belongs to the mask once it reads as one key whole once — asked every
+      // few characters, since a page of "1·1·1…" answers at every piece and
+      // read itself to its square — and from there on to its end.)
+      // (a middot every few characters is a cut's spelling, and it goes on to
+      // its cap: five middots in a run is no text's "·" separator)
+      if (mid && k - i >= 4) midKey = true
+      if (mid && body.length >= RUNCUT && !body.includes(MASKED)) {
+        if (front(words[i][0])) j = k
+        else {
+          if (!midKey && (askedAt === 0 || body.length - askedAt >= 4)) {
+            askedAt = body.length
+            midKey = isKeyWord(body, letters) || (body.match(/[A-Za-z0-9]+/g) ?? []).some((r) => keyRun(r, letters))
+          }
+          if (midKey) j = k
+        }
+      }
+    }
+    if (j === i) {
+      continue
+    }
+
+    // where the key starts: the run's own head, and the first key-shaped word
+    // of a run that begins in a frame ("the key AKIAIOSFODNN 7EXAMPLE"). A
+    // word key-shaped on its own and longer than 16 is the whole key
+    // ("ghp_…EfG h9012…"), not a front with a second key behind it
+    let head = i
+    // a run starts at its first word unless that word is only the frame the
+    // key was written in ("the ms-…", "no key ghp_"); a word key-shaped on its
+    // own ("sk-ant-api03-Eyai1pkJrF") is where the key begins, not the pieces
+    // after it
+    // (a word in a frame is judged by its own key material: "(ghp_…" is where
+    // the key begins, and reading it as a bare "(" moved the head past it)
+    // a vendor front at the word's own start is the word's start, braces or not
+    const iHead = front(words[i][0]) ? words[i][0] : keyFrontOf(words[i][0])
+    const iFrontAt = keyAt(iHead, letters) && !(letters === false && keyAt(words[i][0], letters))
+    for (let q = i + 1; q <= j && !headFront && !shapedBody && !(iFrontAt || keyAt(words[i][0], letters)); q += 1) {
+      const y = tailOf(words[q][0])
+      if (y.length <= 16 && (keyAt(y, letters) || (y.length >= 8 && /\d/.test(y) && /[A-Z]/.test(y)))) {
+        head = q
+        break
+      }
+    }
+    const hp = words[head][0]
+    // where the key's own text begins in the head word. A word with no frame
+    // punctuation that reads as a key is the whole key — a UUID, an ms- key, a
+    // slashed secret: the separators inside it are the key's ("123e4567-e89b-…"),
+    // and cutting at the last letters-and-digits left most of it in the frame.
+    // A frame's punctuation ("key=…", "(…)") hides the key behind it when the
+    // frame carries no word of its own; a frame that does ("NickName=[") is
+    // read from the word's letters and digits, as before.
+    const frameCut = Math.max(0, ...'=:([{,"\''.split("").map((c) => hp.lastIndexOf(c) + 1))
+    const framed = hp.slice(frameCut)
+    const frameWord = /[A-Za-z0-9]{2,}/.test(hp.slice(0, frameCut))
+    // a piece of a hex key cut by whitespace — "123e4567-e89b", "9f8e7d6c5b4a3928"
+    // — is the key's from its own first character, not from its last
+    // letters-and-digits: reading it as a tail began the run at "e89b" and left
+    // "123e4567-" on the card (measured: twelve characters of a UUID where the
+    // mask allows four). The hex letters are what tells the piece from a date
+    // ("2026-11-10" has digits and hyphens but no a–f) and from a word.
+    const hexPiece = /^[0-9a-f]+(?:-[0-9a-f]+)*$/i.test(hp) && /\d/.test(hp) && /[a-f]/i.test(hp) && hp.length >= 8
+    const ht =
+      frameCut === 0 && (keyAt(hp, letters) || hexPiece)
+        ? hp
+        : hp.match(FRONT_IN)?.[0] ?? (frameCut > 0 && !frameWord && keyAt(framed, letters) ? framed : tailOf(hp) || hp)
+    const hf = hp.slice(0, hp.length - ht.length)
+    // the head is a stem of a front the run goes on with ("ms", "sk", "ms-":
+    // the key begins at the stem), and its hyphen is the front's own
+    // (a word that only starts a front — "(gh", "xa" of "xoxb-" — is one too)
+    const stem = head === i && headFront && !front(hp) && !STEM.test(hp) && /^-*$/.test(hf) && FRONT_PART.test(hf)
+    // the separators the key was cut by stay inside the mask (a digest is one
+    // key, "9f8e·7d6c·…" as much as "9f8e 7d6c …"), but a middot or bullet
+    // that is the card's own separator does not ("Qwen3-Max · 调用返还").
+    // A run that begins in a frame ("ms-a 1A1…") starts at its head
+    let rest = words.slice(head + 1, j + 1).map((w) => w[0])
+    // a word after a middot that the run picked up only to keep reading is the
+    // text's ("AKIA… · 4 次"): the mask stops at the last piece the key needed
+    // (a head that is the text's last word has no word after it to read)
+    // (the trim belongs to the card's own separator, "·" with a space on one
+    // side: a bare middot is a cut's spelling and its pieces are the key's,
+    // "12·3e·45·…·40·00" — trimming a piece dropped "00" from the mask and
+    // left the head covering only the first piece)
+    if (head + 1 < words.length && midOf(head + 1) && /^[ \t\u00a0\u3000]/.test(gap(head + 1))) {
+      const endsText = s.slice(end(j)).trim() === ""
+      // (a caption after a spaced middot is the card's own separator's next
+      // entry — "Qwen3-Max · Qwen3-Coder", "qwen3-max · qwen3-max": a model's
+      // name is no piece of a key, and the run is where it was)
+      const text = (w) => caption(w) || (!endsText && w.length <= 2)
+      // (every piece of the run must be read up to it, and the run still has
+      /* eslint-disable-next-line no-irregular-whitespace */
+      // to read as a key whole: "file1 · file2 · file3 · file4" is a list)
+      while (rest.length > 1 && rest[rest.length - 1].length <= 4 && !isKeyWord([ht, ...rest].join(""), letters) && (text(rest[rest.length - 1]) || !isKeyWord(words.slice(i, j + 1).map((w) => w[0]).join(""), letters))) rest = rest.slice(0, -1)
+      while (!endsText && rest.length > 0 && rest[rest.length - 1].length <= 2) rest = rest.slice(0, -1)
+    }
+    // a hyphen the cut left on the front's end ("ms-" then "0123") is the
+    // front's own, and the key may begin with it
+    if (stem && /^-$/.test(rest[0] ?? "")) rest[0] = ht + "-"
+    const run = stem ? rest : [ht, ...rest]
+    // the frame's closing punctuation is the frame's ("(ghp_…7890)", not
+    // "(ghp_…90)"): the mask's last four characters are the key's own
+    let whole = rest.length === words.slice(head + 1, j + 1).length
+    // the run's last words can be the key's even when they added no shape of
+    // their own ("…·789·0"): what the run read is masked. The mask is the
+    // run's to its end — key-shaped from the head's own material ("ghp_") or
+    // long enough to be a key — and the frame the run read past ("· 4 次") is
+    // trimmed below. (A mask whose first twenty characters read as a key stops
+    // at the cut it found; one that reads only at length is a piece that was
+    // joined, and the pieces after it are the key's.)
+    const head20 = ([ht, ...rest].join("").match(/[A-Za-z0-9]+/g) ?? []).some((r) => keyRun(r.length > 20 ? r.slice(0, 20) : r, letters))
+    const long20 = [ht, ...rest].join("").length >= 20
+    if (whole && readTo > j && !(head20 && long20) && isKeyWord([ht, ...rest].join(""), letters) && !/^[a-z]{3,}$/.test(words[readTo][0])) {
+      rest = words.slice(head + 1, readTo + 1).map((w) => w[0])
+      whole = rest.length === words.slice(head + 1, readTo + 1).length
+    }
+    // a middot-joined run of the head's own front is the key through every
+    // piece it read ("Ghp_Abcd1234·Efgh5678·…"): the pieces are the key's, and
+    // none of them is the text's. It still has to read as a key once whole —
+    // seventeen characters of a word and a numeral ("file1·file2·file3",
+    // "AKIA… · 4") is a list, not a key cut, and is read piece by piece.
+    // The run stopped at is kept out of the mask: a word after a middot is the
+    // text's. (A middot without a space is a cut's, and takes the last piece.)
+    // (what the run read, its middots read as spaces: "file1 · file2 · …" is
+    // a list of words with numerals, and together they read as a key)
+    const fronted = headFront && run.length > 1 && midOf(head + 1) && wholeRun
+    if (fronted) whole = readTo === j
+    let tailP = ""
+    if (whole && run.length > 0) {
+      const tail = run[run.length - 1].match(/[^A-Za-z0-9_+/=\-]+$/)?.[0] ?? ""
+      if (tail && tail !== run[run.length - 1]) {
+        tailP = tail
+        run[run.length - 1] = run[run.length - 1].slice(0, -tail.length)
+      }
+    }
+    // (a cut can leave a bare hyphen as a piece, "ms- 0123": dropped)
+    // (a run of the head's own front keeps its cut's middots only when it is
+    // one key whole: a mask over a list of pieces was "…" among the text's)
+    // (a middot-joined run keeps its cut's middots only when it is one key
+    // whole: a mask over a list of pieces was "\u2026" among the text's)
+    const keepSep = !fronted && run.every((w) => /^\w+$/.test(w))
+    const keyText = run.join("").replaceAll(MASKED, "").replace(keepSep ? /[·•∙‧・⋅]/g : /$^/g, "").replace(/^-+/, "")
+    out.push(s.slice(from, at(head)), hf, maskToken(keyText), tailP)
+    // the mask ends at the last piece it kept; a word after a middot that the
+    // run read past is text, and stays as written ("… · 4 次")
+    from = whole ? end(j) : end(head + Math.max(rest.length, 0))
+    i = j
+  }
+  return out.join("") + s.slice(from)
+}
 
 // keyShaped catches a key this plugin does not hold. tokenShaped knows only
 // the ms- prefix, so a server — or a proxy in front of it — that echoes
@@ -683,15 +1493,18 @@ const tokenShaped = new RegExp(String.raw`m${INV}*s${INV}*-(?:${INV}*[\x21-\x7e]
 // floor but which together are — a key written as nUJqxrpd9Bc7-GvG7J--o… or
 // AbCdEfGh.IjKlMnOp… (measured on the card before that arm was added: all 34
 // of the first, all 35 of the second). A word does not qualify — which is what
-// keeps "每日签到", a model tier or a rule_key readable on the card.
+// keeps "Daily check-in", a model tier or a rule_key readable on the card.
 const RUN = /[A-Za-z0-9]+/g
 // the characters a key's word can be built from; punctuation outside this set is
 // the frame around it ("…", a trailing full stop, a comma)
 const IDCH = new Set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=_.-")
-const keyRun = (r) =>
-  (r.length >= 16 && /[a-z]/.test(r) && /[A-Z]/.test(r)) ||
+const keyRun = (r, letters = true) =>
+  (letters && r.length >= 16 && /[a-z]/.test(r) && /[A-Z]/.test(r)) ||
   (r.length >= 32 && /\d/.test(r) && /[A-Za-z]/.test(r)) ||
-  (r.length >= 16 && /\d/.test(r) && /[A-Z]/.test(r)) ||
+  // (a nickname is judged without the case-mix arms — WangXiaoming2026 is a
+  // word — but an all-caps id with a digit in it is still a key, and it is the
+  // only shape those arms would have caught that the others do not)
+  (r.length >= 16 && /\d/.test(r) && /[A-Z]/.test(r) && (letters || r === r.toUpperCase())) ||
   // 16+ of hex with both a letter and a digit in it: a digest, a session id, a
   // fragment of a key. Not a word (abcdefgh… carries letters that are not hex,
   // modelscope20261031 carries more than hex), and not a number
@@ -747,10 +1560,45 @@ const base64y = (w) => {
 // flipping pieces, is what keeps the vendor key (one flipping piece) from
 // being lost
 const alternates = (w) => (w.match(/[a-z][A-Z]/g) ?? []).length >= 2
-const isKeyWord = (w) => {
+// A slice of a generated key can be handed back with no known key to compare
+// against — "no key 5gli9zadx8zg9jez for provider" from a host whose
+// getAuth failed — and a 12–15-character lowercase run has no case mix, no
+// digit by shape alone and no length floor to catch it. Its letters do not
+// read as a word: a run of them has few vowels (usually none), letters and
+// digits alternate, or digits make up much of it. A real word — "modelscope",
+// "workbuddy", "trae-global" — carries vowels; a long provider id with a date
+// in it sits under the length floor. The band is narrow on purpose: 40 and
+// over is the other shapes' business, and under 12 the fragments a legitimate
+// message carries (a version, a rule id) are short enough to stay.
+const VOWELS = /[aeiouy]/g
+const randomish = (r) => {
+  if (r.length < 12 || r.length > 40 || !/[a-z]/.test(r)) return false
+  if ((r.match(VOWELS) ?? []).length / r.length >= 0.2) return false
+  const digits = (r.match(/\d/g) ?? []).length
+  const transitions = (r.match(/[a-z][0-9]|[0-9][a-z]/g) ?? []).length
+  return transitions >= 2 || digits >= 4
+}
+// (a run whose every piece is a word with a numeral — "file1file2file3…" — is
+// a list: no key's word is a word, and a middot run of them was asked at every
+// piece)
+const LISTY = /^(?:[A-Za-z]+\d+)+$/
+const isKeyWord = (w, letters = true) => {
   if (w.length < 12) return false
+  // (a word followed by its numeral — "d8e3a6f0b5c9" — is no match: the
+  // letters there are not a word)
+  if (LISTY.test(w) && /[A-Za-z]{3,}/.test(w)) return false
+  // an upper-cased vendor key is the same key, and its pieces are too short
+  // for the run floors ("SK-ANT-API03-EYAI1PKJRF_KBWT"). A provider id in
+  // lower case ("sk-preset-20261031") is not this arm's
+  // (its letters and digits must alternate, as "SK-ANT-API03-EYAI1PKRF_KBWT"
+  // does; a sentence in capitals has words without digits between them)
+  if (VENDOR.test(w) && w === w.toUpperCase() && /[0-9]/.test(w) && !/[A-Z]{6,}/.test(w.toUpperCase().replace(/^[A-Z]+_[A-Z]+_/, ""))) return true
+  // a run with no word in it (a slash of a key a host printed with no key in
+  // hand) is judged by shape; the caller that knows a name from a key skips
+  // this arm by passing `letters: false` (nameText, when a name is being shown)
+  if (letters && /^[a-z0-9]+$/.test(w) && randomish(w)) return true
   if (!/[\\/]/.test(w)) {
-    if (UUID.test(w) || base64y(w) || (w.match(RUN) ?? []).some(keyRun)) return true
+    if (UUID.test(w) || base64y(w) || (w.match(RUN) ?? []).some((r) => keyRun(r, letters))) return true
     // the separators out: a key cut into pieces by - _ . is still one key, and
     // the pieces together are long and alternate case where a name's do not.
     // A word with no separator is not judged here — the run test above has
@@ -763,14 +1611,85 @@ const isKeyWord = (w) => {
   // with a separator it is one key only when it does not start like a path and
   // carries two parts of 12+ characters mixing cases: that is an AWS secret
   // (wJalr…/K7MDENG/bPxRfi…), and a pair of ordinary folder names is not
-  const parts = w.split(/[\\/]/).filter((seg) => seg.length >= 12 && /[a-z]/.test(seg) && /[A-Z]/.test(seg))
-  return !PATHY.test(w) && parts.length >= 2
+  const segs = w.split(/[\\/]/).filter((seg) => seg !== "")
+  const parts = segs.filter((seg) => seg.length >= 12 && /[a-z]/.test(seg) && /[A-Z]/.test(seg))
+  if (!PATHY.test(w) && parts.length >= 2) return true
+  // a key cut into pieces by slashes ("ghp_1234Ab/Cd5678EfGh/9012IjKl34/…"):
+  // many parts, each of them key material rather than a word, and the whole
+  // reads as a key with the slashes taken out. A path's parts carry lower-case
+  // words ("SomeLongDirName" is a name), and a key's parts do not. A slash at
+  // the very start is a path's own, and a key behind a frame starts at its own
+  // front
+  const frontAt = w.search(/ms-|sk-|gh[pousr]_|xox[abposr]-|akia|asia|aida/i)
+  const sub = frontAt > 0 ? w.slice(frontAt) : w
+  if (PATHY.test(sub) || /^[\\/]/.test(sub)) return false
+  const core = sub.replace(/[^A-Za-z0-9]+$/, "")
+  const coreSegs = core.split(/[\\/]/).filter((seg) => seg !== "")
+  // the front's own letters are not a word ("ghp_" opens a key)
+  const frontLen = (core.match(/^(?:ms-|sk-|gh[pousr]_|xox[abposr]-|akia|asia|aida)/i)?.[0] ?? "").length
+  const wordy = (seg, i) => /[a-z]{2,}/.test(i === 0 ? seg.slice(frontLen) : seg)
+  return (
+    coreSegs.length >= 3 &&
+    coreSegs.every((seg) => /^[A-Za-z0-9_+=.-]+$/.test(seg)) &&
+    !coreSegs.some((seg, i) => wordy(seg, i)) &&
+    isKeyWord(compact(core), letters)
+  )
 }
 
+// maskAll is the three readings a card's text gets, in order: the run reading
+// (maskSpaced), the harder cut (maskCut), and then word by word (maskKeys) —
+// whatever one of them finds is masked, and what it masked is left alone by
+// the next two.
+// maskCaps is the key written without its spaces ("AKIAIOSFODNN 7EXAMPLE"),
+// after the run readings: a word mixing capitals and digits, or one from a
+// vendor's front ("AKIA"), joined with the words after it where the join is
+// all capitals and digits — the shape every vendor key keeps — and long
+// enough to be one of them. The join only covers the pieces that are the
+// key's own alphabet; a word outside it ("the key AKIAIOSFODNN7 EXAM PLES
+// here") is where the join stops, and the joined part is what is masked.
+const maskCaps = (s, letters) => {
+  // a body with no capital in it has no vendor key written without its
+  // spaces (every one of their shapes is all capitals and digits). A name
+  // keeps its capitals: "CHRISTOPHER LEE 2026" is all-capitals and long
+  // enough to read as a key without its spaces, and it is a name
+  if (!letters || s.length > 32 * 1024 || !/[A-Z]/.test(s)) return s
+  const words = [...s.matchAll(/[\x21-\x7e]+/g)]
+  const at = (i) => words[i].index
+  const end = (i) => words[i].index + words[i][0].length
+  const out = []
+  let from = 0
+  for (let i = 0; i < words.length; i += 1) {
+    const w = words[i][0]
+    if (!VENDOR.test(w) && !(/^[A-Z0-9]{4,}$/.test(w) && /[A-Z]/.test(w))) continue
+    let j = i
+    let body = w
+    while (j + 1 < words.length && s.slice(end(j), at(j + 1)).length <= 2 && /^[A-Z0-9]{2,}$/.test(words[j + 1][0]) && /^[A-Z0-9]+$/.test(body)) {
+      j += 1
+      body += words[j][0]
+    }
+    if (j === i || body.length < 16 || /[a-z]/.test(body)) continue
+    // an upper-cased vendor shape ("AKIAIOSFODNN7 EXAMPLE") carries a piece of
+    // an id's rhythm: a capital, a digit, short pieces. A word written out in
+    // full ("DOCUMENTATION", "CONFIGURED") is prose in capitals
+    const awsy = /^AKIA[0-9A-Z]{16}$/.test(body)
+    if (!awsy && !/[A-Z][0-9]/.test(body) && !/[0-9][A-Z]/.test(body)) continue
+    out.push(s.slice(from, at(i)), maskToken(body))
+    from = end(j)
+    i = j
+  }
+  return out.join("") + s.slice(from)
+}
+
+// before maskCut: a middot-joined run of a key's shape is the key's own cut
+// (maskSpaced reads it whole, maskCut reads each piece alone), and maskCut
+// draws "·" as a mask's ellipsis when it is on the mask's own edge
+const maskAll = (s, letters) => maskKeys(maskSpaced(maskCut(maskSpaced(maskCaps(s, letters), letters), letters), letters), letters)
 // maskKeys walks the words of a piece of text: one word that is itself a key
 // goes, and inside a word that is not, only the key-like runs and UUIDs go.
 // Punctuation that cannot be part of a key stays where it was, so a card
-// reads "（bonus ghp_16C7…8B4a）" rather than losing its brackets.
+// reads "（bonus ghp_16C7…8B4a）" rather than losing its brackets. A key cut by
+// spaces is not this walk's to find — it sees one word at a time, and four
+// pieces under the floors are four words kept; maskSpaced reads the run.
 //
 // The lead and tail of punctuation are found by walking in from each end, not
 // by an anchored regex. `word.slice(lead).match(/[^…]*$/)` backtracked from
@@ -779,8 +1698,174 @@ const isKeyWord = (w) => {
 // one match, and a server controls the ledger title it sits in. (A word of
 // nothing but punctuation does not show it — the first start position matches
 // cleanly — so the test uses that shape)
-const maskKeys = (s) =>
-  s.replace(/[^\s]+/g, (word) => {
+// maskCut is the harder cut: a key whose front is itself cut, or whose pieces
+// are cut in two ("ghp _12 34A …", "sk-a nt-a pi03 -Eya …"). Read from a head
+// — a word carrying a vendor prefix, or folding the key's own case down to a
+// capital and a digit, or a run of capitals and digits alone (a key written
+// without its spaces: "AKIAIOSF ODNN7EXA MPLE") — the run goes on while every
+// piece is short and none is prose, and the join is a key or the key's pieces
+// keep flipping case between them. The head is where the mask begins.
+const conts = (w) => (/[0-9]/.test(w) || /[A-Z]/.test(w)) && !VENDOR.test(w)
+function maskCut(s, letters) {
+  // a body of many KiB of one-character words costs far more reading than a
+  // card ever shows, and a hook's whole budget is 25 seconds: past 32 KiB the
+  // pass is skipped, and the other two readings (linear in the text) still run
+  if (s.length > 32 * 1024) return s
+  const words = [...s.matchAll(/[\x21-\x7e]+/g)]
+  if (words.length < 3) return s
+  const at = (i) => words[i].index
+  const end = (i) => words[i].index + words[i][0].length
+  const gap = (i) => s.slice(end(i - 1), at(i))
+  const front = (w) => VENDOR.test(w) || /^ms-/i.test(w)
+  // the same gaps as the run reading: a space, a line break, or a middot or a
+  // bullet with at most one space each side
+  const runGap = (k, i) =>
+    /^[ \t\u00a0\u3000\r\n]+$/.test(gap(k)) && gap(k).length <= 2
+      ? true
+      : MIDDOT_GAP.test(gap(k)) && !(caption(words[i][0]) && caption(words[k][0])) && (front(keyFrontOf(words[i][0])) || keyFrontOf(words[i][0]) !== "")
+  // (a middot-joined list of words with numerals — "file1·file2·…", which a
+  // log's separators write — is no key's cut, and its pieces are read on
+  // their own: the join off the head was asked at every head, and a page of
+  // them was read to its square)
+  const listy = (i) => {
+    if (!(i + 1 < words.length && MIDDOT_GAP.test(gap(i + 1)))) return false
+    let t = words[i][0].replace(/\d+/g, "#")
+    for (let q = i + 1; q < words.length && t.length < 64; q += 1) {
+      if (!MIDDOT_GAP.test(gap(q))) break
+      t += words[q][0].replace(/\d+/g, "#")
+    }
+    return /^(?:[A-Za-z]+#)+$/.test(t)
+  }
+  const out = []
+  let from = 0
+  for (let i = 0; i < words.length; i += 1) {
+    const w = words[i][0]
+    // a key written one character per word starts at a piece of one or two
+    // characters inside such a run (five or more one-character words); the
+    // join decides whether the pieces are one key
+    // (the five pieces have to be letters: a page of "1 · 1 · 1 · …" is a
+    // run of ones, not a key typed out, and asking after every one of them
+    // made a 32 KiB body take two seconds)
+    const tiny = w.length <= 2 && /^[A-Za-z]+$/.test(w) && words[i + 4] !== undefined && words.slice(i, i + 5).every((x) => x[0].length <= 2)
+    // (a stem of a front, "ms", "ghp", is a head too: the rest of the front
+    // is in the next piece)
+    const headKey = keyFrontOf(w)
+    // a key's bare front ("sk-") is a head too: its body starts after it
+    const bareFront = /^(?:sk-|gh[pousr]_|xox[abposr]-|sk_)$/i.test(w)
+    if (!VENDOR.test(w) && !conts(headKey) && !tiny && !STEM.test(w) && !bareFront) continue
+    if (!VENDOR.test(w) && listy(i)) continue
+    let j = i
+    let mixedCase = w.length >= 3 && /[a-z]/.test(w) && /[A-Z]/.test(w)
+    let body = w
+    let mixed = false
+    // the reads rule below asked every past piece whether it was a word, at
+    // every start (quadratic on a page of "1 · 1 · …"); one flag says it
+    const readsHead = front(w)
+    let sawWord = false
+    for (let k = i + 1; w.length <= 64 && k < words.length && k - i <= 64; k += 1) {
+      if (!runGap(k, i)) break
+      // the same stop as the run reading: 20 characters of key material is
+      // the floor, and once a cut is found the run goes on to its cap
+      if (body.length >= 96) break
+      const x = words[k][0]
+      mixedCase = mixedCase || (x.length >= 3 && /[a-z]/.test(x) && /[A-Z]/.test(x))
+      if (/^[a-z]{3,}$/.test(x)) sawWord = true
+      const reads = readsHead || (/^[A-Z0-9]{1,2}$/.test(w) && !sawWord)
+      // (a middle piece joined by a middot or a bullet is key material in any
+      // case: "ms-f·orei·gn01·…" is a key cut every four characters)
+      const middled = /^[·•∙‧・⋅]{1,2}$/.test(gap(k))
+      if (j > i && !reads && !/[0-9A-Z]/.test(x) && !middled && !(body.length >= 24 && !/^[a-z]{1,3}$/.test(x))) break
+      // a run with no digit and no mixed-case word can become no key (the
+      // same reading as the run pass), and one that can is read to the cap
+      if (j === i && body.length >= RUNCUT && !/\d/.test(body) && !mixedCase && !middled) break
+      if (j === i && body.length >= 4 * RUNCUT) break
+      // a key cut once into a long piece ("ghp_1234AbCd5678EfG h9012…") keeps
+      // reading when the piece is key material: digits beside letters
+      if (x.length > 16 && !(x.length <= 64 && /\d/.test(x) && /[A-Za-z]/.test(x)) && !VENDOR.test(x)) break
+      // a piece of one capital and lower-case letters right after the head is
+      // a word on its own ("sk-User"), and a word of four or more lower-case
+      // letters inside the run is prose ("the team") — unless the head is a
+      // run of capitals and digits, where every piece is the key's
+      if (/^[A-Z][a-z]+$/.test(x) && k === i + 1 && !/[0-9]/.test(body)) break
+      // a lower-case word after a run of capitals and digits is the text's
+      // ("see AKIAIOSFODNN7EXAMPLE here"): the run is the key, whole
+      if (/^[a-z]{3,}$/.test(x) && /^[A-Z0-9]+$/.test(body)) break
+      // and after a run that already reads as a key ("ms-foreign-… for provider")
+      if (/^[a-z]{4,}$/.test(x) && isKeyWord(body, letters)) break
+      // a short word of the text's ends the run once a cut has been read, or
+      // when the body already reads as a key ("ghp_…Qrst for provider" keeps
+      // its "for"; the "for" of "ms-0123 for provider" too)
+      if (/^[a-z]{1,3}$/.test(x) && (j > i || isKeyWord(body, letters))) break
+      // the same piece-versus-prose split as the run reading: four lower-case
+      // letters end the run unless the run starts at a key's front
+      if (/^[a-z]{4,}$/.test(x) && body.length >= 4 && !/[0-9]/.test(body) && !/^[A-Z0-9]+$/.test(body) && (x.length > 4 || !(VENDOR.test(w) || /^ms-/i.test(w)))) break
+      body += x
+      if (body.length < 20 || body.includes(MASKED)) continue
+      const whole = body.length >= 16 && (body.match(/[A-Za-z0-9]+/g) ?? []).some((r) => keyRun(r, letters)) // every keyRun arm floors at 16
+      const flips = body.match(/[a-z][A-Z]/g) ?? []
+      // (only asked once both is on the table; most of a run's words carry one case)
+      let pairMix = -1
+      let shortMix = false
+      if (whole || flips.length >= 2) {
+        const run = words.slice(i, k + 1)
+        // a caption ("Qwen3-Max") is mixed case too, and a list of them is not
+        // a key: a key's words flip case inside themselves ("i1pkJrF")
+        pairMix = run.filter((y) => /[a-z]/.test(y[0]) && /[A-Z]/.test(y[0]) && !/^[A-Z][a-z]{2,}/.test(y[0])).length
+        shortMix = pairMix > 0 && run.some((y) => y[0].length <= 12 && /[a-z]/.test(y[0]) && /[A-Z]/.test(y[0]))
+      }
+      if (whole || flips.length >= 2 || (pairMix >= 2 && shortMix)) {
+        j = k
+        mixed = whole || flips.length >= 2
+      }
+    }
+    if (j === i || !mixed) continue
+    const run = words.slice(i, j + 1)
+    // a run of words that are each prose-shaped ("Rebecca Deborah Bradford")
+    // is two runs of words, not a key
+    if (run.every((x) => /^[a-z]{3,}$/i.test(x[0]))) continue
+    // the mask is the key's characters alone; the separators it was cut by
+    // stay inside it, as in the run reading
+    out.push(s.slice(from, at(i)), maskToken(run.map((x) => x[0]).join("").replace(/[·•∙‧・⋅]/g, "")))
+    from = end(j)
+    i = j
+  }
+  return out.join("") + s.slice(from)
+}
+
+const maskKeys = (s, letters = true) => {
+  return s.replace(/[^\s]+/g, (word) => {
+    // The word in the other spellings a key is printed in — full-width
+    // characters, mostly. Nothing below can read it: there is no ASCII body
+    // and no ASCII path prefix, so every pass saw ordinary text. Measured, a
+    // host error carrying "no key ｍｓ－… for provider" printed the whole
+    // token, and NFKC put it back together. The folded copy is what the shape
+    // tests judge, and the word as written is what is masked.
+    const folded = word.normalize("NFKC").replace(/\uFF0D/g, "-")
+    // (the word as written is what is masked, and the folded copy is what is
+    // judged \u2014 but only the key's own span of it: a word's prose is the
+    // word's, and masking the whole took four ideographs of it with the key
+    // ("\u4F59\u989D\u67E5\u8BE2\u5931\u8D25\uFF1A\uFF4D\uFF53\uFF0D\u2026" came out "\u4F59\u989D\u67E5\u8BE2\u20263456"). A fold that keeps
+    // the word's length maps back character for character; one that does not
+    // (a ligature, a squared character) has no span to name, and the word is
+    // masked whole as before)
+    if (folded !== word) {
+      const bodyOf = (w) => {
+        let x = 0
+        while (x < w.length && !IDCH.has(w[x])) x += 1
+        let y = w.length
+        while (y > x && !IDCH.has(w[y - 1])) y -= 1
+        return [x, y]
+      }
+      const readsAsKey = (w) => isKeyWord(w, letters) || (w.match(RUN) ?? []).some((r) => keyRun(r, letters)) || UUID.test(w)
+      if (folded.length === word.length) {
+        const [fa, fb] = bodyOf(folded)
+        if (fb > fa && readsAsKey(folded.slice(fa, fb))) {
+          return word.slice(0, fa) + maskToken(word.slice(fa, fb)) + word.slice(fb)
+        }
+      } else if (readsAsKey(folded)) {
+        return maskToken(word)
+      }
+    }
     let a = 0
     while (a < word.length && !IDCH.has(word[a])) a += 1
     let b = word.length
@@ -793,11 +1878,21 @@ const maskKeys = (s) =>
     // begins with two backslashes, and \ is not in the identity set — stripped
     // as "lead", the rest looked like a relative path with two long camelCase
     // folders and was masked whole (the same test on the word sees PATHY)
-    const masked = isKeyWord(word)
-      ? maskToken(body)
-      : body.replace(RUN, (r) => (keyRun(r) ? maskToken(r) : r)).replace(UUID_ANY, (m) => maskToken(m))
+    // a word with a frame round it ("NickName=[ghp_…") is judged by what the
+    // frame encloses too: the key may start after a bracket or a "="
+    const start = body.search(/[A-Za-z0-9]/)
+    // (a leading slash is a path's frame, not a key's)
+    // a frame is punctuation or path-like ("NickName=[…", "余额查询失败：…"); a
+    // run of capitals and digits before the key is the key's own front
+    // ("SK-ANT-API03-EYAI1PKJRF_KBWT" behind a colon), and is judged whole
+    const encl = start > 0 && body.length <= 512 && !/[\\/]/.test(body.slice(0, start)) && !/[A-Za-z0-9]{2,}/.test(body.slice(0, start)) ? body.slice(start) : ""
+    const masked =
+      (PATHY.test(word) ? false : isKeyWord(body, letters)) || isKeyWord(word, letters) || (encl !== "" && isKeyWord(encl, letters))
+        ? maskToken(body)
+        : body.replace(RUN, (r) => (keyRun(r, letters) ? maskToken(r) : r)).replace(UUID_ANY, (m) => maskToken(m))
     return lead + masked + tail
   })
+}
 
 // cardText is what a host error becomes before it reaches the account card or
 // the terminal. The host's message is not our text: magpie's own CLI scrubs
@@ -822,7 +1917,20 @@ const maskKeys = (s) =>
 const cardText = (value, token, max = 200) => {
   let s = String(value ?? "").replace(GLUE, "")
   if (typeof token === "string" && token) s = s.split(token).join(maskToken(token))
-  return text(maskKeys(maskEchoes(s, token).replace(tokenShaped, (m) => maskToken(m))), max)
+  s = maskEchoes(s, token).replace(tokenShaped, maskShaped)
+  return text(maskAll(s, true), max)
+}
+// The account's own name is text the user picked, not a server's message: a
+// long camelCase name ("MisonLiangWithALongName") is key-shaped to maskKeys and
+// was shown as "Miso…Name" on the card. Names still go through the passes that
+// matter — the key this process holds, the ms- shape, other vendors' key
+// shapes, a bare digest — only the "16+ characters with a case mix" arm is off.
+const nameText = (value, token, max = 200) => {
+  let s = String(value ?? "").replace(GLUE, "")
+  if (typeof token === "string" && token) s = s.split(token).join(maskToken(token))
+  // with no token in hand the mask's shape pass is the only guard there is,
+  // so the case-mix arm has to stay on
+  return text(maskAll(maskEchoes(s, token).replace(tokenShaped, maskShaped), !token), max)
 }
 
 // hostText is cardText for the two exits where there is no token to split on:
@@ -830,7 +1938,7 @@ const cardText = (value, token, max = 200) => {
 // The host's message can still carry one — magpie's own wording for a missing
 // key is "no key <key> for provider" — and these two lines would print it
 // whole. With no key in hand the shape is all there is, which cardText does.
-const hostText = (value) => cardText(value, "")
+const hostText = (value) => nameText(value, "")
 
 // unusableName is a nickname that must not be written back: empty, the token
 // itself or a piece of it (the server would be handed it twice), a key the
@@ -844,60 +1952,354 @@ const hostText = (value) => cardText(value, "")
 // key-shaped to the card as well, and it is not a key — a generated key nearly
 // always carries a digit or a base64 symbol, and a name nearly never does, so
 // nameIsKey asks for one of those beside the card's verdict.
-// The piece is looked for before the cut to 40: a token longer than 40, cut
-// to 40, is no longer equal to the token, and its front would be written to
-// plugin-auth.json as the account's name. A substring of 20+ characters is
-// the piece; a nickname of a few characters that happens to sit inside a
-// token ("ms", "ab") is a nickname.
+// tightName is a name with the characters an echo may insert taken out. A
+// server that echoed the token into a nickname can space it out just as a
+// message can, and "ms-01234567 89abcdef…" is no longer a substring of the
+// token — but the tight form is.
+const tightName = (name) => name.replace(/[\s\p{Cc}\p{Cf}]+/gu, "")
+// flatName keeps only the characters a token is made of. Any other character
+// in a name — a space, a comma, a bracket — is something an echo inserted, and
+// the token's own characters survive in order.
+const flatName = (name) => name.replace(/[^A-Za-z0-9]/g, "")
+// insideToken: the name is in the token, or its tight form is, or its flat
+// form is a run of the token's flat form. Either way every character of it is
+// already in plugin-auth.json, so writing it back leaks nothing new — which is
+// what makes nameIsKey skip it. A token that holds the name is the proof; it
+// does not matter how long the name is.
+const insideToken = (name, token) => {
+  if (typeof token !== "string" || token === "") return false
+  if (token.includes(name) || token.includes(tightName(name))) return true
+  const flat = flatName(name)
+  const t = fold(token)
+  if (flat.length >= 20 && t.includes(flat)) return true
+  // the same answer for the case and compatibility folds: an upper-cased or
+  // full-width name is the same characters the sign-in already holds
+  const n = fold(name)
+  return n.length >= 20 && t.includes(n)
+}
+// echoesToken: the name is the token being handed back — the token itself, or
+// a piece long enough to be an echo. The threshold is the mask's own (MIN_ECHO,
+// 10) rather than the 20 it used to be: a nickname of 10–19 characters is not
+// a name a person picks, and the card's `user` line printed it whole while the
+// mask said nothing about pieces that short. A name of a few characters that
+// happens to sit inside a token ("ms", "ab") is still a name.
+const echoesToken = (name, token) => {
+  if (typeof token !== "string" || !token) return false
+  if (name.includes(token)) return true
+  const n = fold(name)
+  const t = fold(token)
+  if (!n || !t) return false
+  if (n.includes(t)) return true
+  return insideToken(name, token) && tightName(name).length >= MIN_ECHO
+}
+// runsThrough: the name's folded characters carry MIN_ECHO of the token's, in
+// order, even when the echo spaced them out with characters the token does not
+// hold. maskEchoes stops at a filler ("ms-0123abcd4567x 89ef…" is pieces each
+// under MIN_ECHO), but the pieces still spell the key once the filler is
+// dropped, and a nickname is written to plugin-auth.json as a second copy of
+// it. A name that shares a dozen characters of a 32-character key in order is
+// not a name a person picks; a short name ("ms", "Mison") cannot reach the
+// floor.
+//
+// The run is measured as the longest run the name shares with the key, not by
+// one greedy pass: a stray character at the name's start or end used to take
+// the key's first or last position on that pass and hide the body behind it
+// ("f 01234567x 89abcde0x …" either way round). Ordinary nicknames share 6 or
+// 7 characters in a row with a realistic key; a key body spelled out shares
+// 30+.
+//
+// A name can reach a run by luck too: a nickname that is a string of digits
+// is a run of any key holding them in order ("1234567890" is nine characters
+// of most of them). A run is taken for the key when it is most of the name (a
+// dozen characters and half of it, or twenty of it however short the name is),
+// or when the name's whole folded self is a run of the key that a person's
+// name could not be — anything but digits, spaces and hyphens ("bbbb 2222"
+// against a key with those characters in a row).
+const MANY = MIN_ECHO + 2
+const BACK_MANY = MANY + MIN_ECHO
+// The DP below is n × t cells. Neither side is bounded by this plugin: the
+// name comes from the server's answer (a 256 KiB body is allowed) and the key
+// from the host's sign-in. Measured before this cap existed: a 128 KiB name
+// against a 32 Ki-character key spent 19 s of CPU inside a hook whose whole
+// budget is 25 s, and an ordinary 128 KiB nickname against a realistic key
+// spent ~1.8 s. No answer needs that: the write-back is cut to 40 characters,
+// so a longer name is not a name a person picks, and refusing it is the safe
+// direction. The cell cap keeps the work under ~60 ms at the measured rate and
+// refuses the name instead of spending the budget on it.
+const NAME_LCS_MAX = 512
+const LCS_CELLS = 2_000_000
+function longestRun(n, t) {
+  let prev = new Int32Array(t.length + 1)
+  let cur = new Int32Array(t.length + 1)
+  for (let i = 1; i <= n.length; i += 1) {
+    for (let j = 1; j <= t.length; j += 1) {
+      cur[j] = n[i - 1] === t[j - 1] ? prev[j - 1] + 1 : Math.max(prev[j], cur[j - 1])
+    }
+    const swap = prev
+    prev = cur
+    cur = swap
+    cur.fill(0)
+  }
+  return prev[t.length]
+}
+const runsThrough = (name, token) => {
+  const n = fold(name)
+  const t = fold(token)
+  if (n.length < MIN_ECHO || t.length < MIN_ECHO) return false
+  if (insideToken(name, token) && n.length < 20) return false
+  // too long a name to be a name, or too much DP work to spend a hook's budget
+  // on: treat it as unusable, which is what the write-back does with any name
+  // it cannot vouch for. The card still shows its usual mask for the shape.
+  if (n.length > NAME_LCS_MAX || t.length > NAME_LCS_MAX || n.length * t.length > LCS_CELLS) return true
+  const run = longestRun(n, t)
+  if (run >= MANY && (run * 2 >= n.length || run >= BACK_MANY)) return true
+  // a nickname that is almost nothing but the key's characters, in the key's
+  // order, is the key written with something between its characters. A string
+  // of digits is not: those are a run of any key that holds them, and a name
+  // made of them says nothing about which.
+  return run >= MIN_ECHO && run * 3 >= n.length * 2 && !/^[\d\s-]+$/.test(tightName(name))
+}
 const nameIsKey = (name, token) =>
-  !(typeof token === "string" && token.includes(name)) &&
-  name.split(/\s+/).some((w) => isKeyWord(w) && (/\d/.test(w) || /[+/=]/.test(w)))
+  !insideToken(name, token) &&
+  name.split(/\s+/).some(
+    (w) =>
+      isKeyWord(w) &&
+      ((w.match(/\d/g) ?? []).length >= 6 || /[+/=]/.test(w) || /^[0-9a-f]{16,}$/i.test(w)),
+  )
 const unusableName = (name, token) =>
   !name ||
   name === token ||
-  (typeof token === "string" && ((name.length >= 20 && token.includes(name)) || name.includes(token))) ||
+  echoesToken(name, token) ||
+  runsThrough(name, token) ||
   nameIsKey(name, token) ||
+  nameShape(name) ||
   ["__proto__", "constructor", "prototype"].includes(name)
+// nameShape: the name is a credential of a shape this sign-in does not hold —
+// another account's key, or this one's written in another spelling. The tests
+// above look for the token in hand; a server echoing a *different* key
+// ("ｍｓ－…" in full width, a bare 32-character body) matched none of them and
+// was written back as accountId. Only credential shapes count: an ordinary
+// name, camelCase or carrying a year (WangXiaoming2026), is a name.
+//
+// The ms- arm is the shape the card's own mask uses (tokenShaped), not a
+// narrower list of characters: a nickname written as ms-foreign_key… carries an
+// underscore, the card masks it, and the narrow arm passed it through to be
+// stored as the account's name — the one field the card's mask does not reach.
+// Every character a header can carry is a key's character, so the question is
+// the shape, not the spelling.
+const nameShape = (name) => {
+  // the same invisible-character join the card runs before its shape test:
+  // "ms-foreign​_key…" is the same key to the card, and a nameShape that
+  // read it as "ms-foreign_key…" (with a zero-width space in it) refused it by
+  // luck rather than by rule. The space fold after it is for a name written
+  // with spaces between the pieces — a shape that survived the key comparison
+  // in another spelling.
+  const u = name.replace(GLUE, "").normalize("NFKC")
+  const t = u.toLowerCase().replace(/\s+/g, "")
+  // the ms- arm asks the card's own question of the body (keyBody): a word
+  // after the front is a name ("ms-interviewing" is one, and refusing it left
+  // the account with no name at all). A name that is a key of another vendor —
+  // sk-ant-api03-Eyai1pkJrF_Kbwt has three digits and satisfied none of
+  // nameIsKey's extra requirements — is the shape the vendor's own prefix
+  // marks, and a vendor key's body is what the shape tests already accept.
+  // the card's own two questions of an ms- body: does it begin like a key
+  // (tokenShaped), and does the run after the front read as one (keyBody),
+  // both asked of the name as written — spaces and all. Asking them of the
+  // space-folded name let a version number join a short word into a body, and
+  // "ms-cli 2026.11.9" and "ms-office 2016" — names the card shows untouched
+  // — were refused their write-back. A name with pieces spaced out is still
+  // refused by the flat forms above when it is this token's
+  return /^ms-/.test(t)
+    ? [...u.matchAll(tokenShaped)].some((x) => keyBody.test(x[0]))
+    : VENDOR.test(t) ||
+        /^[0-9a-f]{16,}$/.test(t) ||
+        UUID.test(t)
+}
 
-async function rememberAccountName(profile, client, token, name, auth, dir) {
+// withStreak puts the streak on an answer only when it was read to the end.
+// An explicit `streak: undefined` is not "said nothing": the host reads the
+// field with num(), and undefined becomes 0 — a card showing "0 天" for a run
+// the plugin could not see the end of. The key is left out instead, and the
+// answer is told about an expiry the walk met on the way (`marks`), which the
+// walk records because a claim that already landed still has to reach the
+// host as "the token was refused".
+const withStreak = (answer, streak, marks) =>
+  ({
+    ...answer,
+    ...(streak === undefined ? {} : { streak }),
+    ...(marks?.expired ? { signIn: "expired" } : {}),
+  })
+// WRITE_WAIT_MS caps how long a hook waits for the host's write-back. The
+// lock it takes can block for ~20s (host.js's lockAuth, when another process
+// holds plugin-auth.json), and magpie runs every provider's check-ins under
+// one two-minute budget — one contended account must not eat a third of it
+// for a field the card can live without.
+const WRITE_WAIT_MS = 3000
+
+// BOUNDED is what bounded answers when the timer won: the promise's own value
+// could be undefined, and "the host never answered" must not read as "the host
+// said nothing".
+const BOUNDED = Symbol("bounded")
+const bounded = (p, ms) => {
+  let timer
+  const alarm = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(BOUNDED), Math.max(0, ms))
+    if (timer && typeof timer.unref === "function") timer.unref()
+  })
+  return Promise.race([p, alarm]).finally(() => clearTimeout(timer))
+}
+
+// waitFor resolves when `p` settles or after `ms`, whichever comes first; the
+// loser is left running. The timer is unref'd so it never holds a process open.
+const waitFor = (p, ms) => {
+  let timer
+  const alarm = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms)
+    if (timer && typeof timer.unref === "function") timer.unref()
+  })
+  return Promise.race([p, alarm]).finally(() => clearTimeout(timer))
+}
+
+// rememberAccountFields tells magpie what the plugin learned about this
+// sign-in: the account's own name (so the card reads "Mison" instead of
+// "API key …a1b2"), and — for an account on the international site — the site
+// itself, so a restarted host does not have to hand the token to the domestic
+// site for a 401 first. A site the probe has since found to be wrong is
+// removed. The sign-in is written as it already is — the same key, no second
+// copy of the token — with those fields beside it; what is already there is
+// left alone. Everything goes in one write: auth.set takes plugin-auth.json's
+// lock, and two writes would take it twice.
+async function rememberAccountFields(client, token, learned, auth, dir, budgetEnd = Infinity, getAuth) {
   // "can write" is a function, not a truthy value: `{ auth: { set: 1 } }` is a
   // client that cannot write, and `!client?.auth?.set` let it through to call
-  // a number — the TypeError is caught below, but it logs "account name not
+  // a number — the TypeError is caught below, but it logs "account facts not
   // written back" on every check-in, a failure report for a client that never
   // had a chance to succeed.
-  if (!name || typeof client?.auth?.set !== "function") return
-  if (auth?.accountId === name) return
+  if (typeof client?.auth?.set !== "function") return
+  // auth.set replaces the whole sign-in, and the copy the hook read when it
+  // started can be a minute old by the time the requests are done. Written on
+  // top of that copy, an edit made meanwhile is undone: a new key pasted in
+  // while the hook ran was overwritten with the old one, and a field added
+  // was dropped. The host only refuses the write when the account is gone
+  // entirely (host.js's `had && !(key in all)`), so the read is repeated here
+  // and the write lands on the freshest copy. A sign-in that no longer holds
+  // this key is not this key's account any more: the facts learned here are
+  // about a token it no longer carries, so nothing is written.
+  let base = auth
+  if (typeof getAuth === "function") {
+    try {
+      // The read is host I/O like the write: it takes the same store lock and
+      // can block for ~20s. Capped by the same budget, and an unreadable store
+      // means no write at all — falling back to the copy from the start of the
+      // hook is exactly the stale base that overwrote a key pasted meanwhile.
+      const cap = Math.max(0, Math.min(WRITE_WAIT_MS, budgetEnd - Date.now()))
+      // Nothing left of the hook's budget: the read and the write both take
+      // the host's store lock, and starting either at zero would spend the
+      // time the answer was supposed to fit in. The fields are best-effort.
+      if (cap <= 0) return
+      const now = await waitFor(Promise.resolve().then(getAuth), cap)
+      // what the host hands over is not always a plain object (a callable
+      // carrying the fields is a sign-in too); the key is what says it is
+      // still this account's entry, and the spread below skips a non-object
+      if (now === undefined || tokenOf(now) !== token) return
+      base = now
+    } catch {
+      return
+    }
+  }
+  const name = learned?.name ?? ""
+  // Only the international site is worth keeping: a probe tries the domestic
+  // one first, so recording it saves no request and costs a locked write.
+  const site = learned?.profile?.site === INTL.site ? INTL.site : ""
+  const wantSite = !!site && base?.site !== site
+  // A sign-in that names a site but the probe found the account on the
+  // domestic one is stale — the key was replaced under it. Left alone, every
+  // restart would pay a 401 against the site it names, so it is dropped. The
+  // probe has to have actually found the domestic site for this to mean
+  // anything: after a failed read, `learned.profile` is null, the site was
+  // simply not reached, and clearing it would be an own-goal on a blip.
+  const wantClear =
+    !site &&
+    learned?.probeDone &&
+    typeof base?.site === "string" &&
+    base.site !== ""
   const at = named.get(token)
-  if (at !== undefined && Date.now() - at < NAME_AGAIN_MS) return
+  const cooling = at !== undefined && Date.now() - at < NAME_AGAIN_MS
   // an account the user has named keeps that name: writing the nickname over
   // it would re-key their alias to a label the account no longer has. A
   // providers.json that can't be read says the same thing — don't write over
   // a state we can't see.
-  if (aliasOf(profile.id, dir, labelOf(auth, token)) !== "") return
-  named.delete(token)
-  named.set(token, Date.now())
-  while (named.size > NAMES_MAX) named.delete(named.keys().next().value)
-  try {
-    // auth.set replaces the whole sign-in, so what the host handed us is the
-    // base: a field we do not know about is kept, not dropped
-    const body = { ...(auth && typeof auth === "object" ? auth : {}), type: "api", key: token, accountId: name }
-    await client.auth.set({ path: { id: profile.id }, body })
-  } catch (e) {
-    // the card keeps the key's tail; nothing else depends on this. Put the
-    // token back so the next ask tries the write again, and let the log call
-    // be truly best-effort: a host whose log is synchronous returns undefined
-    // where a promise is expected, and that must not throw out of here.
+  const wantName =
+    !!name && base?.accountId !== name && !cooling && aliasOf(ID, dir, labelOf(base, token)) === ""
+  if (!wantName && !wantSite && !wantClear) return
+  if (wantName) {
     named.delete(token)
-    // the message can carry whatever the host put in it; scrub the token out
-    // of it before it reaches magpie's log
-    const why = cardText(whyOf(e), token)
+    named.set(token, Date.now())
+    while (named.size > NAMES_MAX) named.delete(named.keys().next().value)
+  }
+  try {
+    // auth.set replaces the whole sign-in, so the freshest copy the host
+    // handed us is the base: a field we do not know about is kept, not dropped
+    const body = {
+      ...(base && typeof base === "object" ? base : {}),
+      type: "api",
+      key: token,
+      ...(wantName ? { accountId: name } : {}),
+      ...(wantSite ? { site } : {}),
+    }
+    if (wantClear) delete body.site
+    // auth.set takes plugin-auth.json's lock and, when another process holds
+    // it, can block for up to ~20s (host.js's lockAuth). The answer is worth
+    // more than this best-effort write, and a check-in round serves every
+    // provider under one two-minute budget, so the wait is capped: a write
+    // still waiting past the cap finishes behind the hook instead of holding
+    // it. A rejection that comes after the cap is handled where it lands —
+    // reported and retried on the next ask — so a locked store does not cost
+    // an hour of the nickname's cooldown with no sign that anything failed.
+    const writing = Promise.resolve(client.auth.set({ path: { id: ID }, body }))
+    // the handler is attached before the race so a rejection that lands after
+    // the cap still finds one; both sides of the cap run the same report
+    // one report per write: the failure reaches both the attached handler and
+    // the race, and a doubled line would read as two failed writes
+    let reported = false
+    const failed = (e) => {
+      if (reported) return
+      reported = true
+      onWriteFailed(e, client, token, wantName)
+    }
+    // The cap is the hook's own budget end as well as WRITE_WAIT_MS: a hook
+    // that spent its reads right up to the budget must not spend three more
+    // seconds waiting for a lock, or the whole hook outlives the number the
+    // README promises. A write still pending then finishes behind the hook.
+    const cap = Math.max(0, Math.min(WRITE_WAIT_MS, budgetEnd - Date.now()))
+    writing.catch(failed)
     try {
-      const r = client?.app?.log?.({ body: { level: "warn", service: profile.id, message: `account name not written back: ${why}` } })
-      if (r && typeof r.catch === "function") r.catch(() => {})
-    } catch {
-      // a host whose log throws synchronously must not turn a successful
-      // check-in into a failed one, nor a usage read into a rejection
+      await waitFor(writing, cap)
+    } catch (e) {
+      failed(e)
     }
+  } catch (e) {
+    // a synchronous throw from the host's own set(): same report, same retry
+    onWriteFailed(e, client, token, wantName)
+  }
+}
+
+// onWriteFailed is the one report for every failed write, whether it failed at
+// once or after the wait was capped: the name goes back so the next ask tries
+// again, and the reason is logged without the token in it. Best-effort — a
+// host whose log is synchronous returns undefined here, and that must not
+// throw out of the caller.
+function onWriteFailed(e, client, token, wantName) {
+  if (wantName) named.delete(token)
+  // the message can carry whatever the host put in it; scrub the token out of
+  // it before it reaches magpie's log
+  const why = cardText(whyOf(e), token)
+  try {
+    const r = client?.app?.log?.({ body: { level: "warn", service: ID, message: `account facts not written back: ${why}` } })
+    if (r && typeof r.catch === "function") r.catch(() => {})
+  } catch {
+    // a host whose log throws synchronously must not turn a successful
+    // check-in into a failed one, nor a usage read into a rejection
   }
 }
 
@@ -907,16 +2309,22 @@ const signedOut = (e) => Boolean(e?.signIn === "expired" || e?.expired)
 // object without a message, a host's own rejection value — would reach String()
 // as "[object Object]", which tells the user nothing and reads like a bug in the
 // plugin. The empty string lets the caller say something of its own instead.
-const whyOf = (e) =>
-  typeof e?.message === "string" && e.message ? e.message : typeof e === "string" ? e : ""
+const whyOf = (e) => {
+  const m = typeof e?.message === "string" && e.message ? e.message : typeof e === "string" ? e : ""
+  // a body nested deep enough to overflow the identity pass is a shape this
+  // plugin does not read, and the card must not carry the runtime's English
+  // sentence for it
+  return m.includes("Maximum call stack size exceeded") ? "账单格式不认识：嵌套过深" : m
+}
 
 // EXPIRED is what a 401 says, wherever it is met: the ledger read before the
 // touch, the touch itself, or either of usage's two reads. Three wordings
-// used to exist for one condition ("令牌失效或不属于国内站", the same plus
-// "（HTTP 401）", and a bare "HTTP 401" from the balance/ledger path), and the
+// used to exist for one condition ("the token is invalid or not from the CN
+// site", the same plus an HTTP 401 suffix, and a bare "HTTP 401" from the
+// balance/ledger path), and the
 // README's troubleshooting row promises the user will see the status code in
-// it — which only two of the three carried. `where` is the profile's 国内站/
-// 国际站, and stays in the one wording so the card says which site refused
+// it — which only two of the three carried. `where` is the profile's CN site /
+// INT site, and stays in the one wording so the card says which site refused
 // the token.
 const expired = (where) => `令牌失效或不属于${where}（HTTP 401）`
 
@@ -934,19 +2342,47 @@ const RISK = "被魔搭风控拒绝（HTTP 403）"
 // gate turns a reply that is not an answer into the error it is, so the four
 // reads that talk to ModelScope (the ledger, the touch, usage's balance and
 // usage's ledger) do not each carry their own copy of the four checks. `what`
-// names the read in the message ("账单查询失败" / "余额查询失败" / "登录接口
-// 失败"); `risk` is the 403 wording, which the touch alone extends with the
-// retry it can promise. `profile` is there for the one site-specific word a
-// 401 carries (国内站/国际站).
+// names the read in the message ("ledger query failed" / "balance query
+// failed" / "login endpoint failed"); `risk` is the 403 wording, which the
+// touch alone extends with the retry it can promise. `profile` is there for
+// the one site-specific word a 401 carries (the CN site / the INT site).
 //
 // The parse check and the status check are separate on purpose: a body that
 // does not parse is not JSON; a body that parses and carries a 429/500 is the
-// server saying why in its own words (「请求过于频繁」「系统繁忙」). Merged,
-// a JSON-carrying 429 was reported as "响应不是 JSON" and sent the user to
-// check their proxy.
+// server saying why in its own words ("too many requests" / "system busy").
+// Merged, a JSON-carrying 429 was reported as "the response is not JSON" and
+// sent the user to check their proxy.
 const gate = (profile, res, body, parsed, token, what, risk = RISK) => {
-  if (res.status === 401) throw deadToken(profile.where)
-  if (res.status === 403) throw new Error(risk)
+  // A 401 is the token being refused only when it is ModelScope's own JSON.
+  // A proxy's HTML 401 ("proxy authentication required") is the path, not the
+  // sign-in, and signing the account out over it costs the user their login:
+  // it falls through to the ordinary error, and the host retries in half an
+  // hour.
+  // the same question at the other two statuses: a 401 or a 403 that does not
+  // read as ModelScope's is the path answering, not the account — a proxy's
+  // challenge JSON said the sign-in expired, and a proxy's HTML 403 was
+  // reported as ModelScope's risk control
+  if (res.status === 401 && parsed && !awaitsSignIn(body)) throw new Error(`${what}：HTTP 401（响应不是魔搭的）`)
+  if (res.status === 401 && parsed) throw deadToken(profile.where)
+  // a 403 is ModelScope's risk control only when it answers in its own shape
+  // (the success envelope, words in it); a proxy's "proxy denied" page or its
+  // "authentication required" JSON is the path, and is reported as a plain
+  // refusal of that status
+  // ModelScope's own envelope is success or Code/data, in either case, and a
+  // success:false is the site's too (a login layer's {"Success":false,
+  // "Message":"RiskControl"}); a plain refusal with words in it and none of
+  // those fields is any gateway's error page
+  // `in` needs a value with fields: a JSON body of 17, true or "busy" parses
+  // fine, and asking it for "success" threw the engine's own English sentence
+  // ("Cannot use 'in' operator to search for 'success' in 17") at the hook,
+  // with the request's name and the HTTP status lost. A non-object body is a
+  // reply this plugin does not understand, and says so below.
+  const shaped = parsed && body !== null && typeof body === "object"
+  const envelope = shaped && !Array.isArray(body) && (("success" in body) || ("Success" in body))
+  const msLogin = shaped && !Array.isArray(body) && (("Code" in body) || ("code" in body) || ("data" in body) || ("Data" in body))
+  const pathSaid = PATH_MARK.test(JSON.stringify(body))
+  if (res.status === 403 && !pathSaid && (envelope || msLogin)) throw new Error(risk)
+  if (res.status === 403) throw new Error(`${what}：响应不是魔搭的（HTTP 403）`)
   if (!parsed) throw new Error(`${what}：响应不是 JSON（HTTP ${res.status}）`)
   if (res.status !== 200 || !okOf(body)) throw new Error(`${what}：${saidOf(body, token) || `HTTP ${res.status}`}`)
 }
@@ -955,11 +2391,526 @@ const gate = (profile, res, body, parsed, token, what, risk = RISK) => {
 // The day is read at each call, on purpose: a check-in that crosses midnight
 // between its reads reports what its touch granted on the new day, which is
 // true, where diffing both reads against the old day would answer inactive.
-async function todayEarn(profile, token, deadline) {
-  const { res, body, parsed } = await json(profile.site, token, `${TXNS}?page=1&page_size=${PAGE_SIZE}`, deadline)
+async function todayEarn(token, deadline, opts = {}) {
+  const { profile, res, body, parsed } = await siteRead(token, `${TXNS}?page=1&page_size=${PAGE_SIZE}`, deadline)
   gate(profile, res, body, parsed, token, "账单查询失败")
   const day = todayCN()
-  return recordsOf(body).filter((r) => r?.type === "EARN" && onDay(r?.gmt_created, day))
+  const first = recordsOf(body)
+  const { all, pages, complete, scanComplete, last, seenPages, seenRows, total, refused } = await dayRows(profile, token, day, first, deadline, body, opts)
+  return {
+    profile,
+    day,
+    all,
+    pages,
+    complete,
+    scanComplete,
+    refused,
+    last,
+    seenPages,
+    seenRows,
+    // the number the walk finished on, not the first page's: a total that grew
+    // on a later page (or was printed only there) is the one that says whether
+    // the streak's next page is worth reading
+    total,
+    rows: all.filter((r) => r?.type === "EARN" && onDay(r?.gmt_created, day)),
+  }
+}
+
+// DAY_PAGES bounds the extra ledger reads a page full of today's rows costs.
+// Rows come newest first, so today's rows sit at the top and spill onto the
+// next page only when today alone holds more rows than a page. A page whose
+// oldest row is already before `day` is where they end.
+const DAY_PAGES = 4
+
+// dayRows returns the rows the caller already read plus the pages that can
+// still hold `day`'s rows, and whether the walk proved it saw the end of
+// them. A page is followed when it is full and holds nothing older than
+// today, and — the case a server contradicts itself in — when it has room to
+// spare but its `total` still promises rows this walk has not seen: a short
+// page that is not the last one used to end the walk, and a day whose
+// remaining rows sat behind it was read as a complete ledger.
+//
+// `complete` says the end was proved: a page older than `day`, a page with
+// room to spare whose `total` the rows in hand account for, or an empty page
+// with no `total`. An extra page that fails (a transport error, a 5xx, a body
+// that is not JSON), a budget already gone, or a `total` still ahead of the
+// rows stops the walk with `complete` false — the numbers are a floor, and
+// the check-in must not read "no grant today" into a ledger it could not
+// finish. `pages` is the highest page read, so the streak walk resumes after
+// it instead of asking for a page twice (the second read counted its rows
+// again and made the ledger look finished one page early).
+// stable is a value's identity with its object keys sorted: JSON.stringify
+// keeps insertion order, so the same rows with their fields in another order
+// read as a different page and were summed twice. `deep` bounds the recursion:
+// a body nested thousands deep overflowed the stack and answered the card with
+// the runtime's English sentence; past the bound a value is identified by its
+// depth alone, which keeps the pass cheap and total (a server that sends such
+// a row has no identity to lose).
+const STABLE_DEPTH = 64
+const stable = (v, deep = 0) =>
+  deep > STABLE_DEPTH
+    ? `"<depth ${deep}>"`
+    : Array.isArray(v)
+      ? `[${v.map((x) => stable(x, deep + 1)).join(",")}]`
+      : v && typeof v === "object"
+        ? `{${Object.keys(v)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${stable(v[k], deep + 1)}`)
+            .join(",")}}`
+        : JSON.stringify(v)
+const rowKey = (r) => stable(r)
+// idOf is the row's identity as the server names it: `id` when the row has
+// one, the whole-row key when it does not. The ledger may recount an
+// aggregate between two page reads — same id, new numbers — and the
+// whole-row key read that as a second row (12 credits of spend showed as 22).
+// Rows without an id are not merged: two rows that happen to share a tuple
+// are still two rows unless the server says they are one.
+const idOf = (r) =>
+  r?.id !== undefined && r?.id !== null && r.id !== "" ? `id:${String(r.id)}` : ""
+
+async function dayRows(profile, token, day, first, deadline, body, { expiry = true } = {}) {
+  const all = [...first]
+  let rows = first
+  let pages = 1
+  // A page seen before is the page number being ignored, and a row seen before
+  // is the server shifting its window between reads: the same grant then sits
+  // at the bottom of one page and the top of the next, and summing both
+  // reports it twice.
+  const seenPages = new Set([stable(first)])
+  const seenRows = new Set(first.map(rowKey))
+  // the aggregate behind each row already counted, and where it sits in `all`:
+  // a row that comes back with the same identity but new numbers replaces the
+  // one in hand (the later read is the newer read) instead of being summed
+  // beside it
+  const byId = new Map()
+  first.forEach((r, i) => {
+    const id = idOf(r)
+    if (id && !byId.has(id)) byId.set(id, i)
+  })
+  let { total, contradicted } = totalOf(body, first)
+  let complete = false
+  // Two questions end this walk, and they are not the same one. The day's
+  // numbers are proven complete by a page older than the day, a total the rows
+  // account for, or a page with room to spare. The card's countdown needs
+  // more: a daily grant runs 24 hours, so yesterday's grant can be the soonest
+  // to expire, and only a row older than yesterday proves that none can
+  // follow. Once the numbers are proven the walk keeps reading — bounded by
+  // the page cap and the budget — for that scan alone, and a page that fails
+  // there ends the scan without touching the numbers: a 401 met after the
+  // claim still does not undo the claim.
+  const dayOf = (r) => String(r?.gmt_created ?? "").slice(0, 10)
+  const yesterday = new Date(Date.parse(`${day}T00:00:00Z`) - 86400e3).toISOString().slice(0, 10)
+  let dayDone = false
+  // whether the countdown's scan reached the point where no running grant can
+  // follow (a page holding nothing from yesterday or today). The numbers can
+  // be proven whole while this is still open: the card then shows the
+  // earliest expiry it saw and says the scan was cut short.
+  let scanDone = false
+  // the token was refused on a courtesy page: the numbers stand, and the
+  // account is expired (the caller reports it)
+  let refused = false
+  // the walk ended on a page that reached back past the day: the only ending
+  // where another page can still hold a running grant
+  let endedByOlder = false
+  // no row on the page is older than yesterday: a page that reached back past
+  // the day and holds none of those closes the countdown's window, because a
+  // running grant is at most 24 hours old and the rows are newest first
+  const noOlderThanYesterday = (rs) =>
+    !rs.some((r) => {
+      const s = dayOf(r)
+      return isDay(s) && s < yesterday
+    })
+  for (;;) {
+    const older = rows.some((r) => {
+      const s = dayOf(r)
+      return isDay(s) && s < day
+    })
+    if (!dayDone) {
+      if (older) {
+        dayDone = true
+        endedByOlder = true
+      }
+      // The number the page printed beside its rows is the whole ledger's
+      // count: when the rows in hand already account for it, there is no next
+      // page to read for the day's numbers, whether this page was full or not.
+      else if (!contradicted && total !== null && all.length >= total) dayDone = true
+    }
+    // A full page with no `total` that the walk stopped reading (the page cap,
+    // the budget) is a truncation, not an end: the ledger may continue past
+    // it. It used to be called complete here, and a day with 300 rows answered
+    // 250 with no "未读完" on the card and no failed on the check-in. Proving
+    // the end needs a page older than the day, a page with room to spare, or a
+    // total the rows account for. Once proven, a cut costs only the scan.
+    if (total === null && rows.length >= PAGE_SIZE && (pages > DAY_PAGES || deadline <= Date.now())) {
+      complete = dayDone
+      // the page the cap stopped on can already be the window's end: it
+      // reached past the day and holds a row older than yesterday, which is
+      // the same evidence the walk below asks for. Without this the card
+      // printed "到期时间可能更早" for a window the rows in hand had closed.
+      // A page of nothing but today's rows closes nothing — the cap cut the
+      // walk before yesterday's grants were read, and the scan is a floor —
+      // and neither does one that reached yesterday but stopped short of an
+      // older row: the next page can still carry one that expires sooner.
+      scanDone = !expiry || (endedByOlder && !noOlderThanYesterday(rows))
+      break
+    }
+    // a page with room to spare is the end — unless `total` still promises
+    // rows, in which case the server is contradicting itself and the rest may
+    // be on the next page anyway (bounded by DAY_PAGES below)
+    // a `total` below the rows beside it is the ledger contradicting itself:
+    // it proves neither "this is the end" nor "there is more", so the page is
+    // walked on like a short page with no total at all
+    if (!dayDone && rows.length < PAGE_SIZE && !contradicted && (total === null || all.length >= total)) dayDone = true
+    if (dayDone) {
+      // A near-running grant must have landed within the last 24 hours, so it
+      // sits in yesterday's rows or today's. Another page is worth reading
+      // only when this one reached back into yesterday and holds nothing older
+      // than it: the numbers' own endings (a total the rows account for, a
+      // page with room to spare) mean the ledger was read to its end already
+      // and cost no second read.
+      const reached = endedByOlder && !rows.some((r) => {
+        const s = dayOf(r)
+        return isDay(s) && s < yesterday
+      })
+      if (!expiry || !reached || pages > DAY_PAGES || deadline <= Date.now()) {
+        complete = true
+        scanDone = !expiry || !reached
+        break
+      }
+    } else if (pages > DAY_PAGES || deadline <= Date.now()) {
+      // the page cap cut a walk whose numbers were already proven: the day is
+      // complete (an older page or a total said so), and only the countdown's
+      // scan is cut short — the check-in must not read this as a book it could
+      // not finish
+      if (dayDone) complete = true
+      break
+    }
+    let got
+    try {
+      got = await json(profile.site, token, `${TXNS}?page=${pages + 1}&page_size=${PAGE_SIZE}`, deadline)
+    } catch {
+      if (dayDone) complete = true
+      break
+    }
+    const { res } = got
+    // the same rule gate applies to the first page: only a 200 carrying the
+    // success envelope is an answer. A 202 used to be read as the end of the
+    // ledger, which confirmed a day that was never finished. A 401 is the same
+    // token being refused, and swallowing it here kept a confirmed expiry off
+    // the card and out of the check-in's answer: it goes through the same
+    // dead-token throw the first page's gate uses.
+    if (got.parsed && res.status === 401 && awaitsSignIn(got.body)) {
+      // a refusal on a courtesy page (the numbers already proven) ends the
+      // scan without touching them: the claim it was read for stands, as it
+      // did when the walk stopped before this page at all
+      if (dayDone) {
+        complete = true
+        // a refusal on a courtesy page ends the scan without touching the
+        // numbers — but the scan did not reach its end, and the token *was*
+        // refused: the card says the expiry it shows is a floor, and the
+        // account is reported expired instead of the refusal being swallowed
+        refused = true
+        break
+      }
+      throw deadToken(profile.where)
+    }
+    if (!got.parsed || res.status !== 200 || !okOf(got.body)) {
+      if (dayDone) complete = true
+      break
+    }
+    // a page whose shape this walk cannot read — no data, records not a list —
+    // is a page it failed to read, the same as a 500 on it: the walk stops with
+    // the rows it has and `complete` false, so the card says the number is low
+    // and the check-in retries. Letting recordsOf throw here failed the whole
+    // hook with its sentence and threw away the first page's rows.
+    let raw
+    let pageTotal
+    try {
+      raw = recordsOf(got.body)
+      pages += 1
+      // the page's own `total` is checked the way the first page's was: a page
+      // that prints fewer rows than its number promises is contradicting itself
+      // and cannot end the walk on that number.
+      pageTotal = totalOf(got.body, raw)
+    } catch {
+      if (dayDone) complete = true
+      break
+    }
+    if (pageTotal.contradicted) {
+      if (dayDone) complete = true
+      break
+    }
+    // the page's own `total` is the ledger's count as the server sees it now;
+    // a ledger that grew between the reads printed 51 on the first page and 52
+    // on the second, and the walk ended on the first page's number with one
+    // row still unread. The latest number wins, and a total that has grown
+    // keeps the walk going. Only a number the server *printed* can win: a
+    // short page that omits `total` synthesises one from the rows in hand,
+    // and overwriting the known total with it ended a walk before the page
+    // that held the rest of the day's rows (measured: 52 promised, 5 seen,
+    // page 3 never read).
+    //
+    // A printed total below the rows already read, or below one an earlier page
+    // printed, is the ledger contradicting itself — 50 read, then a page
+    // claiming 52 while the rows in hand pass it — and adopting it would end
+    // the walk on the number it just refuted. The walk stops here, incomplete.
+    if (!dayDone && pageTotal.said !== null) {
+      if (pageTotal.said < all.length || (total !== null && pageTotal.said < total)) break
+      total = pageTotal.said
+    }
+    // an empty page is the end of the ledger, or — with a `total` still
+    // counting rows — the server saying two things at once; no page after it
+    // is worth reading. A page repeating one already read is the page number
+    // being ignored, and summing it again would inflate the day's numbers.
+    const stamp = stable(raw)
+    if (!raw.length || seenPages.has(stamp)) {
+      complete = dayDone || (!raw.length && total === null ? true : total !== null && all.length >= total)
+      // an empty page is the end of the ledger: no running grant can follow it.
+      // A repeated page is the server ignoring the page number — the rows are
+      // the ones already read, and a grant older than them (which runs 24 hours
+      // and can expire sooner) may sit on a page the walk never reached, so the
+      // countdown stays a floor there.
+      scanDone = !raw.length
+      break
+    }
+    seenPages.add(stamp)
+    // a row seen before is skipped; the same aggregate with new numbers is not
+    // "fresh" — it is the row in hand, updated
+    const fresh = []
+    const added = []
+    let changed = false
+    for (const r of raw) {
+      const k = rowKey(r)
+      if (seenRows.has(k)) continue
+      const id = idOf(r)
+      // the same id seen before is the same aggregate: the later read replaces
+      // it. Rows the server gives no id for are never merged — two rows that
+      // share a tuple are still two rows.
+      const at = id && byId.has(id) ? byId.get(id) : undefined
+      if (at !== undefined) {
+        all[at] = r
+        added.push(k)
+        changed = true
+        continue
+      }
+      if (id) byId.set(id, all.length + fresh.length)
+      fresh.push(r)
+      added.push(k)
+    }
+    // the set is updated after the page is read, as before: a page that
+    // repeats a row inside itself is summed as many times as it says (the old
+    // filter compared against a snapshot), and a replaced row's new spelling
+    // joins it for the pages after
+    for (const k of added) seenRows.add(k)
+    if (!fresh.length && !changed) {
+      // every row on this page was already counted: the rows are not growing,
+      // and reading on would not change the numbers. That is a fact about the
+      // numbers, not about the window: another page can still hold a running
+      // grant, so the countdown's scan is cut here unless it was asked not to
+      // scan at all (a cut scan is a floor, and the card says so)
+      complete = dayDone || (total !== null && all.length >= total)
+      break
+    }
+    // the page-end proof asks the page that the server sent, not the rows this
+    // walk counted: one repeat on a full page left 49 counted rows, "less than
+    // 50" read as room to spare, and the rest of the ledger — today's grant
+    // included — was never read. A page of nothing but repeats has its own
+    // ending above (an empty or repeated page is the end of the ledger).
+    rows = raw
+    all.push(...fresh)
+  }
+  // `last` is the page the walk stopped on, for a following page-reader to
+  // recognise as already read. It is handed over only when the walk stopped
+  // *without* proving the end (a failed page, a spent budget): there the next
+  // page is the same one again, and reading it twice is what inflated the day.
+  // A walk that proved the end has nothing after it, and an empty page is the
+  // end whatever `total` said — seeding either would make the ledger's next
+  // ask look like a repeat and silence a streak that was read to the last day.
+  return {
+    all,
+    pages,
+    complete,
+    // whether the countdown's own scan reached its end (see scanDone above);
+    // a walk that was not asked to scan at all never started one
+    scanComplete: !expiry || scanDone,
+    refused,
+    total,
+    last: complete || !rows.length ? null : rows,
+    seenPages,
+    seenRows,
+  }
+}
+
+// totalOf is how many rows the ledger holds altogether, from the `total` the
+// page carries beside its `records`; null when that cannot be known. It is
+// what tells a full page from a complete one: the page size caps at 50 (the
+// server answers page_size=200 with 50), so a page that comes back with 50
+// rows may be the whole ledger or the first sliver of it. A page with room to
+// spare is complete by definition, so a missing `total` is answered by the
+// rows in hand there; a full page without one is unknown, and the streak walk
+// leaves its answer unsaid rather than treat the page as the whole ledger.
+//
+// `said` is the distinction the two callers need: the number the server
+// printed, or null. A short page that prints no `total` synthesises one from
+// the rows in hand — correct to read as "that is the whole ledger" for the page
+// it was computed from, and wrong to *overwrite* a number an earlier page
+// printed. Measured: a ledger whose first page promised 52 rows, whose second
+// carried 5 and no total, had the known 52 replaced by the 5 it could see, the
+// walk stopped at 51 rows, and the 300 credits on page 3 were never read.
+const totalOf = (body, rows) => {
+  const n = dataObjectOf(body, "账单格式不认识：没有 data").total
+  // a total below the rows it is printed beside is the ledger contradicting
+  // itself; neither number can be trusted to say whether the page is whole.
+  // That is not the same as a missing total, which the caller reads as "the
+  // rows in hand are the ledger": a short page of a contradicted ledger must
+  // not be called complete on the strength of the number it just refuted.
+  //
+  // A total of another type ("60", 5.5) is the same contradiction, not a
+  // missing one: the server printed a number it did not stand behind, and
+  // reading the short page beside it as "that is the whole ledger" ends the
+  // walk before the pages that hold the rest of today's rows.
+  if (n !== undefined && n !== null && !Number.isInteger(n)) return { total: null, said: null, contradicted: true }
+  if (Number.isInteger(n)) return n >= rows.length ? { total: n, said: n, contradicted: false } : { total: null, said: null, contradicted: true }
+  return { total: rows.length < PAGE_SIZE ? rows.length : null, said: null, contradicted: false }
+}
+
+// prevDay is the Beijing day before `day`. The rows carry date labels with no
+// zone attached, so subtracting on the UTC date is right: the label is a
+// calendar day, not an instant.
+// isDay is a stamp's first ten characters when they name a day that exists.
+// The shape alone let "2026-00-00" through: it sorts before every real day, so
+// it read as an old row and ended a walk on the spot.
+const isDay = (s) => {
+  if (typeof s !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(s)) return false
+  const d = new Date(`${s}T00:00:00Z`)
+  return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === s
+}
+const prevDay = (day) => {
+  const d = new Date(`${day}T00:00:00Z`)
+  d.setUTCDate(d.getUTCDate() - 1)
+  return d.toISOString().slice(0, 10)
+}
+
+// STREAK_PAGES caps how far back the streak walk may read. One page reaches
+// back a fortnight or so on a live account (3–7 rows a day); a run longer
+// than that is followed onto the next page, because on the account this was
+// written for the whole ledger held 16 days of daily grants on page 1 and one
+// row on page 2 — without the second page the run was silently unknown. Eight
+// pages is ~100 days of rows: past that the walk stops and the streak is left
+// unsaid, rather than spend a check-in's budget paging through a year.
+const STREAK_PAGES = 8
+
+// daysWithGrant is the set of Beijing days a list of ledger rows grants a
+// daily rule on, in the "YYYY-MM-DD" shape the rows' stamps start with. A
+// stamp that is not a date is skipped: it does not say which day it grants,
+// so it may not stand for one. (The date shape that matters for the walk
+// itself is checked where stamps are compared as "older than" — see dayRows
+// and streakOf: an empty stamp sorted before every real day and ended a run.)
+const daysWithGrant = (rows, into = new Set()) => {
+  for (const r of rows) {
+    const stamp = typeof r?.gmt_created === "string" ? r.gmt_created.slice(0, 10) : ""
+    if (isDay(stamp) && r?.type === "EARN" && DAILY_RULES.includes(r?.rule_key)) into.add(stamp)
+  }
+  return into
+}
+
+// streakOf is how many consecutive Beijing days up to `day` carried a daily
+// grant — the run magpie prints as "N-day streak" beside a check-in. The
+// first page comes from the check-in's own ledger read; when the run is still
+// going at the oldest row of a page whose `total` says there is more, the
+// next page is read (readPage) and the walk carries on. The answer is
+// undefined when today's grant is not in the rows, and when the walk runs out
+// of pages first: magpie prints any number it is given, so a run it could not
+// see the end of is not told at all rather than told short.
+async function streakOf(records, day, total, readPage, deadline) {
+  const days = daysWithGrant(records)
+  if (!days.has(day)) return undefined
+  let held = records.length
+  let n = 1
+  let d = day
+  for (;;) {
+    const prev = prevDay(d)
+    if (days.has(prev)) {
+      n++
+      d = prev
+      continue
+    }
+    // Nothing grants on `prev`. That is a real break when a row older than it
+    // has been read — the ledger goes on past the gap and still says nothing
+    // that day — or when the rows read are the whole ledger. `total` is null
+    // when a full page did not say how many rows the ledger holds, or said a
+    // number the rows contradict; the next page is the only way to learn
+    // whether that page was the whole ledger, so it is read when there is one.
+    // The date part is compared only when it is a date: an empty or malformed
+    // stamp sorted before every real day and ended the run on the spot.
+    const older = records.some((r) => {
+      const s = typeof r?.gmt_created === "string" ? r.gmt_created.slice(0, 10) : ""
+      return isDay(s) && s < prev
+    })
+    if (older) return n
+    if (total !== null && held >= total) return n
+    if (!readPage || deadline <= Date.now()) return undefined
+    const more = await readPage()
+    if (more === null) return undefined
+    // An empty page settles it: with a known `total` still counting rows it is
+    // the ledger contradicting itself, and nothing after this can be trusted
+    // to be the end of the run; with no `total`, it is the end of the ledger.
+    if (!more.length) return total === null ? n : undefined
+    daysWithGrant(more, days)
+    records = more
+    held += more.length
+  }
+}
+
+// ledgerReader hands streakOf one page at a time, past the pages the check-in
+// already read. `from` is the highest page that read reached: asking for page
+// 2 again would append its rows a second time, and the doubled count made the
+// ledger look finished one page early. It gives up — null, which leaves the
+// streak unsaid — when STREAK_PAGES is spent in all, when a page cannot be
+// read (a 403, a budget already gone), or when the ledger answers with a page
+// that is not a list. A page error must not fail the check-in: the claim has
+// already happened, and the answer it deserves is the one already computed,
+// not a failure the host retries half an hour later.
+const ledgerReader = (profile, token, deadline, from = 1, first = null, seenPages = null, seenRows = null, marks = null) => {
+  let page = from
+  let left = Math.max(0, STREAK_PAGES - from)
+  // every page and row the day walk read, not just the page it stopped on: a
+  // server that cycles through its pages repeated one the walk had already
+  // summed, and counting it again filled the ledger's `total` and let the
+  // streak claim an end it never saw.
+  const seen = new Set(seenPages ? [...seenPages] : [])
+  if (first !== null) seen.add(stable(first))
+  const counted = new Set(seenRows ? [...seenRows] : [])
+  if (first !== null) for (const r of first) counted.add(rowKey(r))
+  return async () => {
+    if (left <= 0) return null
+    left -= 1
+    page += 1
+    try {
+      const { res, body, parsed } = await json(profile.site, token, `${TXNS}?page=${page}&page_size=${PAGE_SIZE}`, deadline)
+      gate(profile, res, body, parsed, token, "账单查询失败")
+      const rows = recordsOf(body)
+      // a page already read (the server ignoring the page number, or cycling)
+      // is not the walk's next step: counted again it fills the ledger's
+      // `total` and ends a streak the walk could not see the end of
+      const stamp = stable(rows)
+      if (seen.has(stamp)) return null
+      seen.add(stamp)
+      // an empty page is the end of the ledger, not a repeat: streakOf reads
+      // it as the proof that the run went as far as there is
+      if (!rows.length) return []
+      const fresh = rows.filter((r) => !counted.has(rowKey(r)))
+      for (const r of fresh) counted.add(rowKey(r))
+      if (!fresh.length) return null
+      return fresh
+    } catch (e) {
+      // a 401 the gate confirmed is the token refused; the walk still gives up
+      // softly (the claim already landed), but the host is told about the
+      // expiry through `marks`
+      if (marks && signedOut(e)) marks.expired = true
+      return null
+    }
+  }
 }
 
 // SURE_HOUR is magpie's checkinSureHour (workbuddy_checkin.go): before noon,
@@ -979,7 +2930,7 @@ const deferred = new Map()
 // nothing but whitespace. The empty string was already refused at both
 // numeric sites; the spaces were not, and `Number("   ")` is 0 — so a blank
 // amount read as "a grant of nothing" (the check-in answers `inactive`, which
-// settles the day) and a blank balance as "0 魔粒可用". A padded number
+// settles the day) and a blank balance as "0 credits available". A padded number
 // (" 251.5 ") is not blank: it says what it means.
 const blankOf = (v) => v === undefined || v === null || (typeof v === "string" && !v.trim())
 
@@ -988,7 +2939,7 @@ const blankOf = (v) => v === undefined || v === null || (typeof v === "string" &
 // 0: the same rule the whole body gets one level up. A localized "1,200", a
 // format change, a null — each would otherwise make a real grant look like
 // "nothing arrived": the check-in would answer `inactive` (which settles the
-// day) and the card would say 领 0 next to a balance that clearly moved.
+// day) and the card would say claimed 0 next to a balance that clearly moved.
 // Absent is included: a row with no amount cannot be summed either way.
 const amountOf = (row) => {
   const raw = row?.total_amount
@@ -1000,7 +2951,7 @@ const amountOf = (row) => {
   const n = Number(raw)
   // readable, not just isFinite: a huge finite value ("1e307") survives isFinite
   // and only blows up at the card, where yin's ×100 overflows to Infinity — so
-  // "Infinity 魔粒" would be printed for a body we cannot actually read. The
+  // "Infinity credits" would be printed for a body we cannot actually read. The
   // same door the balance read and yin itself use.
   if (!readable(n)) throw new Error("账单格式不认识：total_amount 不是数字")
   return n
@@ -1026,11 +2977,7 @@ const yin = (n) => {
 
 const sumOf = (records) => yin(records.reduce((n, r) => n + amountOf(r), 0))
 
-// pluginFor is the whole plugin, with the one profile it serves passed in.
-// magpie calls every exported function as its own plugin entry, so the two
-// exports below are two providers over this one body: same hooks, same
-// wording, one place for both to drift from.
-async function pluginFor(profile, input) {
+export async function MsmoliPlugin(input) {
   // input.directory is magpie's own folder (host.go passes settings.Dir()),
   // which is where a portable magpie keeps everything too.
   const configDir = typeof input?.directory === "string" ? input.directory : ""
@@ -1041,34 +2988,46 @@ async function pluginFor(profile, input) {
 
   return {
     auth: {
-      provider: profile.id,
+      provider: ID,
 
-      // 静态令牌签到：粘贴一把 ms- 开头的访问令牌即可。
+      // A static-token check-in: paste an access token that starts with ms-.
       //
-      // 不声明 prompts，也不声明 authorize：magpie 对 api 型方法本来就会单独
-      // 问一次 key，令牌存为 key 本身。声明 prompts 会让它的答案再被写进
-      // metadata，同一把令牌落盘两遍（host.js 的 save()）；而 authorize 只看
-      // 得到 prompts 的答案，看不到那个 key，没法替代它。格式由 placeholder
-      // 提示，错了由第一次签到或用量读取报 401。
+      // Neither prompts nor authorize is declared: magpie already asks for the
+      // key on its own for an api-type method, and the token is stored as the
+      // key itself. Declaring prompts would write its answer into metadata as
+      // well, putting the same token on disk twice (host.js's save()); and
+      // authorize sees only the answers to prompts, not that key, so it cannot
+      // stand in for it. The placeholder hints at the format; a wrong one shows
+      // as a 401 on the first check-in or usage read.
       methods: [
         {
           type: "api",
-          label: "ModelScope 访问令牌",
+          label: "ModelScope 访问令牌（国内站或国际站）",
           placeholder: "ms-…",
         },
       ],
 
-      // 签到：先看今天到账没有，再触达登录，最后回读对账。直接触达无法区分
-      // 「本次领取」与「早就领过」，而账单能。
+      // The check-in: first see whether today's credits have landed, then touch
+      // the login, and finally read the ledger back to reconcile. A direct touch
+      // cannot tell "just claimed" from "claimed long ago"; the ledger can.
       //
-      // 时段：被问到时若还没到今天这个账号的目标时刻，就在发任何请求之前
-      // 回答 failed——唯一会被宿主重试的结果，别的都会让当天不再被问。
-      // 代价是这段时间卡片上写着「签到失败；magpie 稍后重试」，那是今天
-      // 宿主唯一能表达「还没到点」的说法（上游见 README）。
+      // Timing: when asked, if today's target moment for this account has not
+      // arrived yet, answer failed before sending any request — the one outcome
+      // the host retries; any other one stops the day from being asked again.
+      // The cost is that the card reads "check-in failed; magpie will retry
+      // later" during that stretch, the only way the host has today to say "not
+      // yet time" (see the README's upstream section).
       async checkin(getAuth) {
+        // The whole hook's budget starts here, not after the host hands the
+        // sign-in over: a store read that waits on another process's lock is
+        // this hook's time too, and 18 seconds of it plus a request timeout
+        // put a 25-second hook past its own limit.
+        const deadline = Date.now() + CHECKIN_BUDGET_MS
         let auth, token
         try {
-          auth = await getAuth()
+          const got = await bounded(Promise.resolve().then(getAuth), deadline - Date.now())
+          if (got === BOUNDED) return { outcome: "failed", message: "读取登录信息超时，稍后自动重试" }
+          auth = got
           token = tokenOf(auth)
         } catch (e) {
           return { outcome: "failed", message: hostText(whyOf(e)) || "签到失败", ...(signedOut(e) ? { signIn: "expired" } : {}) }
@@ -1080,10 +3039,6 @@ async function pluginFor(profile, input) {
             // the user to sign in sends them to the wrong place
             message: unusableKey(auth) ? "令牌内容无法识别（含空格、换行或非 ASCII 字符），请重新登录" : "没有登录信息，请先登录",
           }
-        // the clock the requests run against: a hook that does not finish in
-        // time has failed, as far as the host is concerned, and it asks again
-        const deadline = Date.now() + CHECKIN_BUDGET_MS
-
         const today = todayCN()
         const win = windowOf(configOf(configDir))
         if (win) {
@@ -1098,7 +3053,7 @@ async function pluginFor(profile, input) {
             // and it is in the README for whoever wants to change it.
             //
             // No countdown. The host keeps this line on the card until its
-            // next ask, half an hour later, so "约 8 分钟后" outlives the
+            // next ask, half an hour later, so "in about 8 minutes" outlives the
             // eight minutes: a real card still read that at 09:47 for a
             // 09:28 target whose credits had already landed. The target and
             // the cadence are both absolute, and the cadence is also why the
@@ -1106,23 +3061,52 @@ async function pluginFor(profile, input) {
             // it runs on the host's next ask, not at the moment it named.
             return {
               outcome: "failed",
-              message: `${clock(p.target)} 后自动领取（magpie 每半小时问一次，无需操作）`,
+              // the zone is named because only the minute is: the target is
+              // Beijing's whatever zone the host's own clock is in, and the
+              // host shows other times (resets, a window's expiry) in the
+              // machine's zone beside it.
+              message: `${clock(p.target)} 后自动领取（北京时间，magpie 每半小时问一次，无需操作）`,
             }
           }
         }
 
+        // The site the token was found on is kept on the sign-in, so a
+        // restarted host goes straight there instead of handing the token to
+        // the domestic site for a 401 first. A value that is not one of the
+        // two is ignored and the token probed again.
+        const kept = profileForSite(auth?.site)
+        if (kept && !sites.has(token)) rememberSite(token, kept)
+
         // The nickname is written back after the answer is made, not between
         // the touch and the reads that reconcile it: magpie's auth.set takes
         // plugin-auth.json's lock synchronously (host.js's lockAuth, up to
         // twice its 10s stale time when another process holds it), and that
         // wait came out of this hook's 25s — a claim that had landed was then
-        // answered "预算已用完" and shown as failed for half an hour.
+        // answered "budget used up" and shown as failed for half an hour.
+        // The write is also capped (WRITE_WAIT_MS) so a locked store cannot
+        // stretch the hook past its budget even from the tail.
         let name = ""
+        // the site the reads found the token on, for the write-back after the
+        // answer; null until the first read has answered
+        let probe = null
+        // a confirmed expiry met on a read that is allowed to fail softly
+        // (the name lookup, the streak walk): the day's answer stands, and the
+        // host still has to hear that the token was refused
+        const marks = { expired: false }
         const answer = await (async () => {
         try {
-          const before = await todayEarn(profile, token, deadline)
-          const beforeDaily = before.filter((r) => DAILY_RULES.includes(r?.rule_key))
-          const claimed = before.some((r) => r?.rule_key === "daily_active")
+          let before = await todayEarn(token, deadline, { expiry: false })
+          let rolls = 0
+          for (;;) {
+          const profile = before.profile
+          probe = profile
+          const beforeDaily = before.rows.filter((r) => DAILY_RULES.includes(r?.rule_key))
+          const claimed = before.rows.some((r) => r?.rule_key === "daily_active")
+          // A baseline that was not read to the end cannot prove the day's
+          // grant absent: the row may sit on the page that failed, and the
+          // touch-then-diff would report a row nobody read as this run's gain.
+          // `failed` is the one outcome the host retries.
+          if (!before.complete && !claimed) return { outcome: "failed", message: "账单读取不完整，稍后自动重试" }
           // What this run granted is the ledger's growth, not a new key: the
           // rows are aggregated per (day, type, rule_key, model_tier), so a
           // second grant of a rule already in today's page grows that row's
@@ -1130,11 +3114,21 @@ async function pluginFor(profile, input) {
           // aliyun_bindlogin (from the website, say) and gains nothing from
           // the touch must not report "claimed 50" — and one that gains more
           // of a rule it already had must still report it.
+          // Only the daily-rule rows go into the comparison. The ledger also
+          // holds EARN rows of other rules — promotions, bind bonuses — and a
+          // row of one that carries no amount (a server-side adjustment, a
+          // rule added since) would throw here and answer `failed` for a day
+          // whose claim had already landed. Those rows are not what this
+          // comparison is about, so their amounts are never read. It is the
+          // same rule the usage card follows: only the kinds it sums need an
+          // amount.
           const byRule = (rows) => {
             const m = new Map()
             for (const r of rows) m.set(r?.rule_key, (m.get(r?.rule_key) ?? 0) + amountOf(r))
             return m
           }
+          // `beforeDaily` and every `rows` handed to grew(...) are already
+          // filtered to DAILY_RULES by the caller.
           const beforeByRule = byRule(beforeDaily)
           // The name a rule is shown by: the first row of that key that carries
           // one. Rows aggregate per (day, type, rule_key, model_tier), so a key
@@ -1144,11 +3138,15 @@ async function pluginFor(profile, input) {
           // "+50" with nothing in front of it.
           const titleOf = (rows, key) =>
             rows.find((r) => r?.rule_key === key && typeof r.title === "string" && r.title.trim())?.title
-          const grew = (rows) => {
+          const grew = (rows, pageDay) => {
             const after = byRule(rows)
+            // The rows of a new Beijing day cannot be diffed against the day
+            // before it: a grant that landed at 00:00:xx on the 50 already in
+            // yesterday's page would net to zero.
+            const base = pageDay === before.day ? beforeByRule : new Map()
             const out = []
             for (const [key, sum] of after) {
-              const gain = yin(sum - (beforeByRule.get(key) ?? 0))
+              const gain = yin(sum - (base.get(key) ?? 0))
               if (gain > 0) out.push({ key, gain, title: titleOf(rows, key) })
             }
             return out
@@ -1158,13 +3156,46 @@ async function pluginFor(profile, input) {
           // left to do. magpie asks a `done` again every half hour before noon
           // when it has not seen the claim itself (provisional), and each ask
           // touching login/info was one more recorded sign-in — up to a dozen
-          // a morning for an account claimed on the website.
-          const known = names.get(token) ?? ""
+          // a morning for an account claimed on the website. "Known" includes
+          // a remembered "the server gave no usable name" (`names` holds the
+          // empty string then), or the touch would repeat for exactly the
+          // accounts whose nickname is unusable.
+          const known = names.has(token)
           if (claimed && known) {
-            name = known
+            name = names.get(token)
+          } else if (claimed) {
+            // The grant is already in the ledger, so this read is only for the
+            // card's name. A refusal or a broken answer must not turn the day
+            // into `failed`: the host retries a failed day every half hour,
+            // touching login/info each time, for a claim that already landed.
+            name = ""
+            try {
+              const { res, body, parsed } = await json(profile.site, token, LOGIN_INFO, deadline)
+              if (res.status === 401 && parsed && awaitsSignIn(body)) throw deadToken(profile.where)
+              gate(profile, res, body, parsed, token, "登录接口失败", `${RISK}，稍后会自动重试`)
+              const me = dataOf(body)
+              // A name is a string. Anything else — a number, an object, a list —
+              // would reach text() as "12345" or "[object Object]" and be written
+              // back as the account's name, and magpie's card would show that
+              // instead of the key's tail. NickName wins when it is a name; Name
+              // is the fallback it always was.
+              const str = (v) => (typeof v === "string" && v.trim() ? v : "")
+              const raw = str(me.NickName) || str(me.Name)
+              const candidate = text(raw, 40)
+              // judged whole, then cut: the cut can leave a piece of the token
+              // in the name that neither the cut string nor the whole one
+              // answers for alone (see runsThrough)
+              name = unusableName(raw, token) || unusableName(candidate, token) ? "" : candidate
+              rememberName(token, name)
+            } catch (e) {
+              // no name this ask; the day still stands as done — but a 401 the
+              // gate confirmed is the token refused, and the host is told
+              if (signedOut(e)) marks.expired = true
+            }
           } else {
             const { res, body, parsed } = await json(profile.site, token, LOGIN_INFO, deadline)
-            // 403 是风控，不是令牌坏了：账号可能是好的，只是这次请求被拒
+            // A 403 is risk control, not a bad token: the account may be fine and
+            // only this request was refused.
             gate(profile, res, body, parsed, token, "登录接口失败", `${RISK}，稍后会自动重试`)
 
             const me = dataOf(body)
@@ -1174,30 +3205,17 @@ async function pluginFor(profile, input) {
             // instead of the key's tail. NickName wins when it is a name; Name
             // is the fallback it always was.
             const str = (v) => (typeof v === "string" && v.trim() ? v : "")
-            const candidate = text(str(me.NickName) || str(me.Name), 40)
-            name = unusableName(candidate, token) ? "" : candidate
+            const raw = str(me.NickName) || str(me.Name)
+            const candidate = text(raw, 40)
+            // judged whole, then cut: the cut can leave a piece of the token
+            // in the name that neither the cut string nor the whole one
+            // answers for alone (see runsThrough)
+            name = unusableName(raw, token) || unusableName(candidate, token) ? "" : candidate
             rememberName(token, name)
           }
 
-          // done 用触发**之前**那一页的合计：今天已经领过，领到的就是那时
-          // 账本上的数。用触发之后那一页的话，两次读之间账本一变（行被挤到
-          // 下一页、或当日合计被重算），卡片会显示「今日已领取 0 魔粒」。
-          if (claimed) {
-            const credit = sumOf(beforeDaily)
-            const which = beforeDaily.map((r) => cardText(r.title, token, 40)).filter(Boolean).join(" + ")
-            // An EARN row can carry a reversal (冲正), and a day whose grants
-            // were reversed nets below zero. magpie clamps the numeric credit
-            // itself (host.js's num: Math.max(0, v)) but renders `message`
-            // verbatim, so "今日已领取 -50 魔粒" would reach the card: a claim of
-            // a negative amount is not a thing. The rows are still named — the
-            // user can see which ones — but the amount stops at zero, the way
-            // the usage card's limit already does.
-            const shown = Math.max(0, credit)
-            return { outcome: "done", credit: shown, message: `今日已领取 ${shown} 魔粒` + (which ? `（${which}）` : "") }
-          }
-
-          const gained = (rows) => {
-            const grew1 = grew(rows)
+          const gained = (rows, pageDay) => {
+            const grew1 = grew(rows, pageDay)
             if (!grew1.length) return null
             const credit = yin(grew1.reduce((n, g) => n + g.gain, 0))
             // A key with no name on any of its rows is shown by its amount
@@ -1212,18 +3230,128 @@ async function pluginFor(profile, input) {
             return { credit, which }
           }
 
-          const daily = gained((await todayEarn(profile, token, deadline)).filter((r) => DAILY_RULES.includes(r?.rule_key)))
-          if (daily) return { outcome: "claimed", credit: daily.credit, message: `领取 ${daily.credit} 魔粒：${daily.which}` }
-          // 触达了却没有到账记录：可能是账本还没写出来（发放是异步的），
-          // 也可能这个账号本来就不在活动范围。再读一次账本确认，别把刚写
-          // 出来的发放丢掉。这一次重读买不到「等一会儿」——发放若真是几秒
-          // 后才写出来，紧接着的重读也读不到。北京时间 12 点前补上那一段的
-          // 是宿主：还没见到领取的 done/inactive 是暂定答案，每 30 分钟重问
-          // （provisional，由 checkinSureHour 决定）。12 点起宿主就当天了结，
-          // 所以下午的时段由插件自己用 until 要一次半小时后的重问。
-          const later = gained((await todayEarn(profile, token, deadline)).filter((r) => DAILY_RULES.includes(r?.rule_key)))
-          if (later) return { outcome: "claimed", credit: later.credit, message: `领取 ${later.credit} 魔粒：${later.which}` }
+          // The name read above can sit across Beijing midnight: the baseline
+          // is then yesterday's, and answering `done` for it would settle the
+          // new day without claiming it. A day that changed while the hook ran
+          // is re-read and the walk starts over for the new day (twice at
+          // most, so a clock that keeps rolling cannot loop the hook).
+          if (todayCN() !== before.day && rolls < 2) {
+            rolls += 1
+            const wasDay = before.day
+            before = await todayEarn(token, deadline, { expiry: false })
+            probe = before.profile
+            // The touch was this run's, and the day changed under it: the
+            // baseline is yesterday's, and `gained` reads an empty one for a
+            // page whose day is not the one it is handed. So the new day's
+            // whole page is the diff — every daily grant on it was written
+            // between the two reads (the page had nothing for the new day when
+            // the baseline was read). A grant the server stamped with
+            // yesterday's date (a late write) is not on this page at all, and
+            // is not claimed here: it belongs to yesterday's answer, which
+            // this run already gave.
+            const bornToday = gained(before.rows.filter((r) => DAILY_RULES.includes(r?.rule_key)), wasDay)
+            if (bornToday) {
+              return withStreak({
+                outcome: "claimed",
+                credit: bornToday.credit,
+                message: `领取 ${bornToday.credit} 魔粒：${bornToday.which}` + (before.complete ? "" : "；账单未读完，数字偏低"),
+                ...(marks.expired ? { signIn: "expired" } : {}),
+              }, await streakOf(before.all, before.day, before.total, ledgerReader(profile, token, deadline, before.pages, before.last, before.seenPages, before.seenRows, marks), deadline), marks)
+            }
+            if (!before.complete) {
+              return { outcome: "failed", message: "账单读取不完整，稍后自动重试", ...(marks.expired ? { signIn: "expired" } : {}) }
+            }
+            continue
+          }
+
+          // A done uses the totals from the page **before** the touch: if today
+          // was already claimed, what was claimed is the number the ledger held
+          // then. From the page after the touch, a ledger that changed between
+          // the two reads (rows pushed to the next page, or the day's total
+          // recomputed) would make the card say today's claim is 0 credits.
+          if (claimed) {
+            const credit = sumOf(beforeDaily)
+            // each title is cut and stringified as before, and the join is
+            // masked once at the end: two titles that each carry a piece of the
+            // key under MIN_ECHO spell it together, and a per-title mask never
+            // sees the pair.
+            const joined = beforeDaily
+              .map((r) => cardText(r.title, token, 40))
+              .filter(Boolean)
+              .join(" + ")
+            const which = cardText(joined, token, 200)
+            // An EARN row can carry a reversal, and a day whose grants were
+            // reversed nets below zero. magpie clamps the numeric credit
+            // itself (host.js's num: Math.max(0, v)) but renders `message`
+            // verbatim, so a negative claimed-today line would reach the card:
+            // a claim of a negative amount is not a thing. The rows are still
+            // named — the user can see which ones — but the amount stops at
+            // zero, the way the usage card's limit already does.
+            const shown = Math.max(0, credit)
+            // The streak is read from the page **before** the touch here too:
+            // the touch grants nothing new for an account already claimed, so
+            // the two readings answer the same thing, and this one is the page
+            // the totals above were taken from.
+            return withStreak({
+              outcome: "done",
+              credit: shown,
+              message: `今日已领取 ${shown} 魔粒` + (which ? `（${which}）` : "") + (before.complete ? "" : "；账单未读完，数字偏低"),
+              ...(marks.expired ? { signIn: "expired" } : {}),
+            }, await streakOf(before.all, before.day, before.total, ledgerReader(profile, token, deadline, before.pages, before.last, before.seenPages, before.seenRows, marks), deadline), marks)
+          }
+
+          // Both claimed exits answer the same way; the streak is computed in
+          // one place so a change to it cannot land in one branch only.
+          const claimedNow = async (page, gain) => {
+            const streak = await streakOf(page.all, page.day, page.total, ledgerReader(profile, token, deadline, page.pages, page.last, page.seenPages, page.seenRows, marks), deadline)
+            return withStreak({
+              outcome: "claimed",
+              credit: gain.credit,
+              message: `领取 ${gain.credit} 魔粒：${gain.which}` + (page.complete ? "" : "；账单未读完，数字偏低"),
+              ...(marks.expired ? { signIn: "expired" } : {}),
+            }, streak, marks)
+          }
+
+          const fresh = await todayEarn(token, deadline, { expiry: false })
+          probe = fresh.profile
+          const daily = gained(fresh.rows.filter((r) => DAILY_RULES.includes(r?.rule_key)), fresh.day)
+          if (daily) return await claimedNow(fresh, daily)
+          // Touched, yet no credit record: the ledger may not be written yet
+          // (grants are asynchronous), or this account may simply not be in the
+          // campaign. Read the ledger once more to confirm, and do not drop a
+          // grant that was just written. This re-read buys no "wait a while" —
+          // if the grant really is written a few seconds later, the immediate
+          // re-read cannot see it either. Before Beijing noon the host covers
+          // that stretch: a done/inactive that has not seen a claim is a
+          // provisional answer, re-asked every 30 minutes (provisional, decided
+          // by checkinSureHour). From noon the host settles the day, so in the
+          // afternoon the plugin asks for one more ask half an hour later itself,
+          // via until.
+          const again = await todayEarn(token, deadline, { expiry: false })
+          probe = again.profile
+          const later = gained(again.rows.filter((r) => DAILY_RULES.includes(r?.rule_key)), again.day)
+          if (later) return await claimedNow(again, later)
+          // A ledger this walk could not finish is not evidence that nothing
+          // arrived: the grant may sit on the page that failed, and `inactive`
+          // without `until` settles the day on that. The last read is the one
+          // that decides — an earlier incomplete read is answered by this one.
+          // The touch has happened, so the answer that costs nothing is
+          // `failed` — the one outcome the host retries, which reads the
+          // ledger again half an hour later.
+          if (!again.complete) {
+            return { outcome: "failed", message: "账单读取不完整，稍后自动重试" }
+          }
           const hourCN = Math.floor(minuteCN() / 60)
+          // Before noon the host re-asks a provisional answer every half hour,
+          // so an `inactive` here is safe: a grant that is simply late is read
+          // again, and the repeat past noon gets the `until` below. From noon
+          // the host settles the day, so the first `inactive` from noon on
+          // carries `until`, once per day. A check-in that lands just after
+          // midnight is before SURE_HOUR and already covered by the host's
+          // provisional re-ask — that is the guard, and it is the hour, not a
+          // stale day flag: `deferred` holds the Beijing day the `until` was
+          // given on, and a new day starts with no flag, so the afternoon of
+          // the new day gets its own `until` like any other day.
           if (hourCN >= SURE_HOUR && deferred.get(token) !== today) {
             for (const [k, d] of deferred) if (d !== today) deferred.delete(k)
             deferred.set(token, today)
@@ -1233,7 +3361,15 @@ async function pluginFor(profile, input) {
               until: new Date(Date.now() + AGAIN_MS).toISOString(),
             }
           }
+          if (beforeDaily.length) {
+            // no until: this answer settles the day, so the line must not
+            // promise a re-check the host will not make. Today has credits of
+            // other kinds and no check-in reward, which reads as an account
+            // outside the activity rather than a grant still on its way.
+            return { outcome: "inactive", message: "登录已触达，今天有到账但没有签到奖励（账号可能不在活动范围）" }
+          }
           return { outcome: "inactive", message: "登录已触达，但今天没有到账记录（账号可能不在活动范围）" }
+          }
         } catch (e) {
           return { outcome: "failed", message: cardText(whyOf(e), token) || "签到失败", ...(signedOut(e) ? { signIn: "expired" } : {}) }
         }
@@ -1242,37 +3378,50 @@ async function pluginFor(profile, input) {
         // catches its own failures, and anything it could still throw (an
         // unreadable providers.json read) must not undo the answer above
         try {
-          await rememberAccountName(profile, client, token, name, auth, configDir)
+          await rememberAccountFields(client, token, { name, profile: probe, probeDone: !!probe }, auth, configDir, deadline, getAuth)
         } catch {}
         return answer
       },
 
-      // 魔粒余额与今日消耗，给账号卡片看。
+      // The credits balance and today's usage, for the account card.
       async usage(getAuth) {
         // everything the host could get wrong about the hand-over is the
         // card's problem alone: it must come back as {error}, never as a
         // rejection out of the hook
+        const deadline = Date.now() + USAGE_BUDGET_MS
         let auth, token
         try {
-          auth = await getAuth()
+          const got = await bounded(Promise.resolve().then(getAuth), deadline - Date.now())
+          if (got === BOUNDED) return { error: "读取登录信息超时，稍后自动重试" }
+          auth = got
           token = tokenOf(auth)
         } catch (e) {
           return { error: hostText(whyOf(e)) || "用量查询失败", signIn: signedOut(e) ? "expired" : "" }
         }
         if (!token) return { error: unusableKey(auth) ? "令牌内容无法识别，请重新登录" : "没有登录信息", signIn: "" }
-        const deadline = Date.now() + USAGE_BUDGET_MS
+        // the same seeding as the check-in's: a site kept on the sign-in saves
+        // the domestic-site 401 a restarted host would otherwise pay first
+        const kept = profileForSite(auth?.site)
+        if (kept && !sites.has(token)) rememberSite(token, kept)
         // the name is only known from login/info, which usage must never
-        // reach; a check-in in this process leaves it here for the card.
-        // Inside the try: the hook promises an {error}, never a rejection,
-        // and this path reaches client.auth.set.
+        // reach; a check-in in this process leaves it here for the card, and
+        // the write-back of a name the check-in failed to write is retried
+        // here. That write is the last thing before the answer, not the first
+        // thing before the reads: the host's auth.set can wait out a lock for
+        // ~20s (see the check-in's own note), and a wait spent before the
+        // reads came out of the 18s the two of them share — the card answered
+        // "budget used up" for a name it had just written. Everything here is inside
+        // the try, so the hook still promises an {error} and never a
+        // rejection, whatever that write or the reads do.
         try {
-          await rememberAccountName(profile, client, token, names.get(token) ?? "", auth, configDir)
-          const bal = await json(profile.site, token, BALANCE, deadline)
+          const bal = await siteRead(token, BALANCE, deadline)
+          const profile = bal.profile
           gate(profile, bal.res, bal.body, bal.parsed, token, "余额查询失败")
-          // data 缺失读成 0 会把「没读懂」翻译成「余额为零」——一个确定又
-          // 错误的结论，卡片会写「0 魔粒可用」。账本那侧的 recordsOf 同理。
-          // 字段这一层也一样：available_balance 缺失、null、或改了名字，
-          // 都不是 0 元的余额。
+          // A missing data read as 0 would turn "did not understand" into a
+          // definite and wrong conclusion, "balance is zero"; the card would
+          // read "0 credits available". recordsOf on the ledger side is the
+          // same. The field layer is too: available_balance absent, null, or
+          // renamed is not a zero balance.
           const balData = dataObjectOf(bal.body, "余额查询失败：响应里没有 data")
           const rawAvailable = balData.available_balance
           if (blankOf(rawAvailable)) {
@@ -1280,27 +3429,28 @@ async function pluginFor(profile, input) {
           }
           // A number or a numeric string is a balance. Anything else is not:
           // Number([]) is 0 and Number(true) is 1, both finite, so the plain
-          // isFinite check let an empty list through as "0 魔粒可用" — the
+          // isFinite check let an empty list through as "0 credits available" — the
           // definite wrong answer this guard exists to stop — and a boolean
-          // through as one 魔粒. A formatted string ("1,234") is a number we
+          // through as one credit. A formatted string ("1,234") is a number we
           // cannot read, not 0, and blankOf covers the field that holds
           // nothing but spaces, which `Number` also reads as 0.
           const kind = typeof rawAvailable
           if (kind !== "number" && kind !== "string") throw new Error("余额查询失败：available_balance 不是数字")
           const availableN = Number(rawAvailable)
           if (!readable(availableN)) throw new Error("余额查询失败：available_balance 不是数字")
-          // a balance is not a debt: the server's 冲正 direction can put it
-          // below zero, and "-5 魔粒可用" is not a thing the card can show
+          // a balance is not a debt: the server's reversal direction can put it
+          // below zero, and "-5 credits available" is not a thing the card can show
           const available = Math.max(0, yin(availableN))
 
           const tx = await json(profile.site, token, `${TXNS}?page=1&page_size=${PAGE_SIZE}`, deadline)
           gate(profile, tx.res, tx.body, tx.parsed, token, "账单查询失败")
 
           const day = todayCN()
+          const walked = await dayRows(profile, token, day, recordsOf(tx.body), deadline, tx.body)
           let earned = 0
           let spent = 0
           let earliest = ""
-          for (const r of recordsOf(tx.body)) {
+          for (const r of walked.all) {
             // Only the two kinds that go into the card's numbers need an
             // amount. A row of a kind we do not sum is not counted either
             // way, and failing the whole card over its amount would turn a
@@ -1308,10 +3458,13 @@ async function pluginFor(profile, input) {
             // numbers at all" — the opposite of what the rule is for.
             if (onDay(r?.gmt_created, day)) {
               if (r?.type === "EARN") {
-                // 「领」是今天入账的全部，促销一类也算：卡片问的是「今天进来
-                // 多少、用掉多少」，把促销排除会让余额涨了 500 而卡片写「领 0」。
-                // 签到报的 credit 是另一个问题（这次签到领到多少），只算日常
-                // 额度，两个数不一样是各自的答案，不是同一个数的两种算法。
+                // "Claimed" means everything credited today, promotions
+                // included: the card asks "how much came in, how much was
+                // used", and excluding promotions would show "claimed 0" while
+                // the balance rose by 500. The credit the check-in reports is a
+                // different question (how much this check-in claimed), counting
+                // only the daily grants; the two numbers differing is each
+                // giving its own answer, not two ways of computing one number.
                 earned += amountOf(r)
               } else if (r?.type === "SPEND_CONFIRM") {
                 spent += amountOf(r)
@@ -1330,36 +3483,47 @@ async function pluginFor(profile, input) {
             }
           }
 
-          // 不截断到 100：magpie 把 used > 100 读作「超额」
-          // （host.js 的 "past 100 when overspent"）。今天没领到任何魔粒
-          // 且余额为零，才算用尽。下限夹到 0：账本里的退款是负数的
-          // SPEND_CONFIRM，不夹就会在卡片上出现「今日用 -50 / 领 200」和
-          // 负百分比——宿主自己会夹，这里再兜一次。
+          // Not truncated at 100: magpie reads used > 100 as "overspent"
+          // (host.js's "past 100 when overspent"). Today's credits being spent
+          // up means nothing was claimed today and the balance is zero. The
+          // lower bound is clamped to 0: refunds in the ledger are negative
+          // SPEND_CONFIRM rows, and without the clamp the card would show a
+          // "used -50 today / claimed 200" combination and a negative
+          // percentage — the host clamps it itself; this is one more safety net.
           // summed in floating point: 0.1 + 0.2 is 0.30000000000000004, and it
           // would go into the card as written
           earned = yin(earned)
           spent = yin(spent)
-          // 入账方向也可能出现负数（冲正、回收）。不夹的话卡片会写
-          // 「领 -50」，而 limit 是负的更没意义。用掉的方向同理。
+          // The credit direction can also come out negative (reversals,
+          // clawbacks). Without the clamp the card would write "claimed -50",
+          // and a negative limit makes even less sense. Same for the spend
+          // direction.
           const earnedToday = Math.max(0, earned)
           const usedToday = Math.max(0, spent)
-          // 没有今天的入账时，百分比的分母换成「今天手里有多少」——用掉的
-          // 加上还剩的。分母为 0 时沿用旧口径：余额也空了才算用尽。
-          // 否则卡片会出现 used=0、今日用 348.5、领 0 的组合，进度条说没动，
-          // 文字说花掉了一堆。
+          // When there is no credit today, the percentage's denominator becomes
+          // "how much is in hand today" — what was used plus what remains. When
+          // that denominator is 0 the old measure stands: only a depleted
+          // balance counts as spent up. Otherwise the card would show the
+          // combination used=0, used 348.5 today, claimed 0 — the progress bar
+          // says nothing moved while the text says a lot was spent.
           //
-          // 记账里两个数都过了 readable()，比值却可能大到 ×10000 溢出成
-          // Infinity；宿主对非有限的 used 读作 0（host.js 的 num 只认有限数），
-          // 于是「几乎全用光」被画成没动过。算不出百分比就交给宿主当「没说」
-          // （used 省略 = null），文字那行仍然写着真实的数量。
+          // Both numbers in the ledger passed readable(), yet the ratio can be
+          // large enough to overflow to Infinity at ×10000; the host reads a
+          // non-finite used as 0 (host.js's num accepts only finite numbers),
+          // and so "almost all used up" was drawn as nothing having moved. When
+          // the percentage cannot be computed it is handed to the host as "not
+          // said" (used omitted = null), and the text line still states the
+          // real amounts.
           const pct = (n, d) => {
             const v = Math.round((n / d) * 10000) / 100
             return Number.isFinite(v) ? v : null
           }
-          // 用掉的超过今天领的、余额却还有：花的是昨天那份还没过期的魔粒，
-          // 不是超额。那时分母同样换成「今天手里有多少」——否则昨天 15:00
-          // 领 250、今天领 250、上午用掉 300，卡片会画成 120% 的超额，旁边
-          // 写着余额 200。超额只在余额也空了时才成立。
+          // More used than claimed today, yet a balance remains: what was spent
+          // is yesterday's not-yet-expired credits, not an overage. The
+          // denominator switches to "how much is in hand today" then too —
+          // otherwise, 250 claimed yesterday at 15:00, 250 claimed today, 300
+          // used this morning, the card would draw a 120% overage beside a
+          // balance of 200. An overage holds only when the balance is empty too.
           const used =
             earnedToday > 0 && (usedToday <= earnedToday || available === 0)
               ? pct(usedToday, earnedToday)
@@ -1367,21 +3531,49 @@ async function pluginFor(profile, input) {
                 ? pct(usedToday, usedToday + available)
                 : 100
 
-          // 今天还没领到时，把时段里的目标时刻写在卡片上，别让「领 0」
-          // 看起来像是出了问题。
-          const win = windowOf(configOf(configDir))
-          const ahead = win && earnedToday === 0 ? plan(win, token, day) : null
-          const hint = ahead && !ahead.due ? ` · ${clock(ahead.target)} 领取` : ""
+          // Before today's credits are claimed, put the window's target moment
+          // on the card, so "claimed 0" does not look like something went wrong.
+          //
+          // The config is read only when the card actually needs the target:
+          // after the day's grant has landed there is no hint to compute, and
+          // this file read is the hook's only synchronous I/O — a poll every
+          // few minutes per account should not pay for it to be thrown away.
+          // `win` is null when earnedToday is non-zero, so `ahead` is null
+          // exactly where `win && earnedToday === 0` used to make it so.
+          const win = earnedToday === 0 ? windowOf(configOf(configDir)) : null
+          const ahead = win ? plan(win, token, day) : null
+          // the minute is Beijing's (minuteCN), while the card's reset time is
+          // the machine's zone: say which one this is, or a reader elsewhere
+          // takes it for their own clock.
+          const hint = ahead && !ahead.due ? ` · ${clock(ahead.target)} 领取（北京时间）` : ""
+          // A walk that could not finish leaves the two numbers a floor: the
+          // ledger contradicted itself, or a page failed. Said on the card, so
+          // they are not read as the day's whole truth.
+          // the countdown's own scan can be cut short while the numbers are
+          // whole (the page cap, the budget): then the earliest expiry seen is
+          // a floor, not the answer, and the card says so rather than naming a
+          // later time as if it were settled
+          const part = (walked.complete ? "" : " · 账单未读完，数字偏低") + (walked.scanComplete || !earliest ? "" : " · 到期时间可能更早")
+
+          // last, and awaited: the card must not be answered ahead of the
+          // write (a poll answered before it would race the very retry this
+          // exists for), while the reads above have already had the budget to
+          // themselves.
+          await rememberAccountFields(client, token, { name: names.get(token) ?? "", profile, probeDone: true }, auth, configDir, deadline, getAuth)
 
           return {
             plan: profile.plan,
-            user: names.get(token) ?? "",
+            user: nameText(names.get(token) ?? "", token),
             balance: `${available} 魔粒可用`,
+            // a token refused on a courtesy page is refused: the numbers that
+            // page was read for stand, and the card says what the next poll
+            // would say anyway — the account needs signing in again
+            ...(walked.refused ? { signIn: "expired" } : {}),
             windows: [
               {
                 name: "魔粒",
                 used,
-                display: `今日用 ${usedToday} / 领 ${earnedToday} · 余额 ${available}${hint}`,
+                display: `今日用 ${usedToday} / 领 ${earnedToday} · 余额 ${available}${hint}${part}`,
                 amount: usedToday,
                 limit: earnedToday,
                 unit: "魔粒",
@@ -1396,45 +3588,37 @@ async function pluginFor(profile, input) {
       },
     },
 
-    // 让 provider 以名字出现，不注册任何模型：聊天仍走 providers.json 里
-    // API key 版的那个 modelscope 预设。
+    // Make the provider show up by name without registering any model: chat
+    // still goes through the API-key modelscope preset in providers.json.
     async config(config) {
-      // 宿主是 `{ provider: {}, ...userConfig }` 拼出来的，用户配置里那个
-      // provider 会盖掉默认的 {}。它不是对象时（旧版本写的字符串、手改的
-      // 数字），下面 `[profile.id] =` 会抛 TypeError，宿主只把 config 钩子
-      // 的错误记进日志——插件照常出现，只是没有名字，看不出哪里错了。
-      // `??=` 只挡 null/undefined，挡不住 ""、0、false；一个装不下 id 的
-      // 容器里没有可保留的东西，整个换掉。
+      // The host builds `{ provider: {}, ...userConfig }`, and the provider in
+      // the user config overrides the default {}. When that is not an object (a
+      // string an old version wrote, a hand-edited number), the `[profile.id] =`
+      // below throws a TypeError, and the host only logs the config hook's
+      // error — the plugin still appears, just without a name, and there is no
+      // sign of what went wrong. `??=` guards only null/undefined, not "", 0, or
+      // false; a container that cannot hold an id has nothing worth keeping, so
+      // the whole thing is replaced.
       if (!config.provider || typeof config.provider !== "object") config.provider = {}
-      // 用户自己改过的名字留着：magpie 把 provider 的名字存在 providers.json
-      // 里，而钩子每次启动都跑一遍——强制写回默认值会把 UI 里的改名悄悄撤销，
-      // 与账号昵称那条「用户命名过就不动」是同一条规矩。值不是对象时当作没有。
-      const was = config.provider[profile.id] && typeof config.provider[profile.id] === "object" ? config.provider[profile.id] : {}
-      config.provider[profile.id] = {
+      // Keep the name the user has changed: magpie stores a provider's name in
+      // providers.json, and this hook runs on every start — forcing the default
+      // back would silently undo a rename made in the UI, the same rule as the
+      // account-nickname one ("a user-named thing is left alone"). A value that
+      // is not an object counts as none.
+      const was = config.provider[ID] && typeof config.provider[ID] === "object" ? config.provider[ID] : {}
+      config.provider[ID] = {
         ...was,
-        name: typeof was.name === "string" && was.name ? was.name : profile.name,
+        name: typeof was.name === "string" && was.name ? was.name : NAME,
       }
     },
   }
 }
 
-// Two entries: the domestic site (`msmoli`) and the international one
-// (`msmoli-intl`). Exporting two functions makes two providers — magpie's
-// loader takes every exported function as a plugin entry (`testables` is an
-// object, which it skips). The check-in window in msmoli.json is shared: it is
-// a personal preference about when to claim, not a per-site setting.
-export async function MsmoliPlugin(input) {
-  return pluginFor(CN, input)
-}
-
-export async function MsmoliIntlPlugin(input) {
-  return pluginFor(INTL, input)
-}
 
 // testables is how the pure helpers the tests pin are reached without
 // exporting them as functions: magpie's loader treats every exported function
 // as a plugin entry (see windowOf above), but an object it skips. The tests
 // are the only reader.
-export const testables = { windowOf, CN, INTL }
+export const testables = { windowOf, streakOf, CN, INTL, sites, maskAll, cardText, nameText, hostText, awaitsSignIn, gate }
 
 export default MsmoliPlugin