@thincoder/core 0.10.12 → 0.11.1

package/ledger-db.mjs

@@ -22,7 +22,9 @@ import { join, resolve } from "node:path"
 import { DatabaseSync } from "node:sqlite"
 
 import { configDir } from "./config-io.mjs"
-import { MANIFEST_REL, owningProject, projectRootView } from "./manifest.mjs"
+import { MANIFEST_REL, owningProject } from "./manifest.mjs"
+// 无根报明面的候选来源 = 统一解析层（`docs/core/design/PATH-RESOLUTION.md` §2.3——本档不自持候选枚举）。
+import { resolvePathTarget } from "./path-resolve.mjs"
 // 归一步单源（KD-LN1——直引，不抽新 util：先例 = peer-domains.mjs / traces/trace-store.mjs）。
 import { normalizeCwd } from "./session-slots.mjs"
 
@@ -58,11 +60,11 @@ function isRegistered(dir) {
 }
 
 /** 同级枚举上限（成本有界：父目录超此规模 = 缓存 / 临时等非仓族形态 → 退化空集）。
- *  2026-10-16 批 ledger-root-derivation 自 `ledger.mjs` 随迁（同级枚举：族发现 ∥ 轻通道闸候选枚举同源）。 */
+ *  2026-10-16 批 ledger-root-derivation 自 `ledger.mjs` 随迁（同级枚举：族发现单一消费面）。 */
 export const MAX_SIBLING_SCAN = 100
 
 /** 目录下**已注册**（档在盘——§2.1 单谓词）的直接子目录（目录名升序；不可读 ∥ 超限 ⇒ 空集；
- *  **惰性枚举 + 上限**——大目录零全量扫描）。消费面 = 族发现 ∥ 轻通道闸候选枚举。
+ *  **惰性枚举 + 上限**——大目录零全量扫描）。消费面 = 族发现（`thincoder-core/ledger.mjs`）。
  *  `ledger` = 该子目录根的键控库路径（推算值 ⇒ 可能尚未在盘）。2026-10-16 批自 `ledger.mjs` 随迁。 */
 export function ledgerChildren(dir) {
   const out = []
@@ -91,11 +93,11 @@ export function ledgerChildren(dir) {
  *  `ancestor`（最近带档祖先）。「项目根报明 / 建档」由用点决定。
  *  **无自指**：本档不判库在盘（台账无第二定义——库在盘不算项目）。
  *  @param {string} [target] 动作目标路径（目录 | 文件则取其所在目录）
- *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`）
+ *  @param {string} boundary 上溯上界（会话锚——**必传**；缺则该值缺失即失败，不落 `process.cwd()`）
  *  @returns {{root: string, basis: 'self'|'ancestor'}|null} 项目根 + 判据来源 / 无根（`null`） */
 export function resolveLedgerRoot(target, boundary) {
   const start = resolve(target ?? ".")
-  const edge = resolve(boundary ?? process.cwd())
+  const edge = resolve(boundary)
   const root = owningProject(start, edge)
   return root ? { root, basis: root === start ? "self" : "ancestor" } : null
 }
@@ -103,26 +105,26 @@ export function resolveLedgerRoot(target, boundary) {
 /** 无根文案（单源——`openLedger` 写面 ∥ `ledgerDbPath` ∥ 工具面读面（`ledger-tools.mjs`）共用同一句）：
  *  **只陈述事实**——起点 + 上溯上界（界内无项目根），不写「祖先链无已注册项目」这类越界断言：
  *  归属根可能就在界**之上**（界外）——那一格该句为假，读它会教人误判层级。
- *  锚态 = 工作区时追报下辖候选（报明面读数 = `projectRootView` 的 `workspace` 态——
- *  **只供报明，不参与取根**：取根仍以会话锚为界）。
+ *  锚态 = 工作区时追报下辖候选（报明面读数 = 统一解析层的 `ambiguous.candidates`——
+ *  **只供报明，不参与取根**：取根仍以会话锚为界，`resolveLedgerRoot` 零改）。
  *  @param {string} start 起点（动作目标路径）
- *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`）——与 `resolveLedgerRoot` 同一缺省 */
+ *  @param {string} boundary 上溯上界（会话锚——**必传**）——与 `resolveLedgerRoot` 同一口径 */
 export const noRootMessage = (start, boundary) => {
-  const view = projectRootView(start)
-  const edge = resolve(boundary ?? process.cwd())
-  const tail = view.state === "workspace" ? `；下辖候选项目：${view.candidates.join(" ∥ ")}` : ""
+  const picked = resolvePathTarget(start, undefined, { kind: "dir", order: "root-first" })
+  const edge = resolve(boundary)
+  const tail = picked.state === "ambiguous" ? `；下辖候选项目：${picked.candidates.join(" ∥ ")}` : ""
   return `台账：自 ${start} 未找到项目根（向上找到 ${edge} 为止）${tail}`
 }
 
 /** 项目根 → 库路径（稳定键 = `ledgerKey` 前 16 位——路径唯一标识，不含分隔符）。
  *  **归单源**（2026-10-16 批 ledger-root-derivation）：根 = `resolveLedgerRoot(cwd, boundary)`——与读面 / 写面
  *  同一推导；无根 ⇒ 抛**同一**无根文案（键需根，不产第二答案）。
- *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：调用方知道锚就传；
- *  缺省 = `process.cwd()`（CLI / 进程锚 = 会话锚的调用面不必传）。
+ *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：由调用方指名（**必传**）；
+ *  进程工作目录不是界（CLI 的锚只是端 adapter 在装配期写入 `agent.cwd` 的取值）。
  *  v2 键归一（2026-09-25 批）：盘符本大写（CLI）⇒ 键恒等零变；小写盘符（VSC `uri.fsPath`）
  *  并入同键 ⇒ 同项目两端同库（收正前 = 同项目两键两库）。
  *  @param {string} [cwd] 动作目标路径
- *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`） */
+ *  @param {string} boundary 上溯上界（会话锚——**必传**） */
 export function ledgerDbPath(cwd, boundary) {
   const start = resolve(cwd ?? ".")
   const derived = resolveLedgerRoot(start, boundary)
@@ -133,33 +135,32 @@ export function ledgerDbPath(cwd, boundary) {
 /** 未决四态（「活条目」口径 = 计数单源 WHERE 集；已核销 / 已废弃 = 归档态）。 */
 export const PENDING_STATUSES = ["待讨论", "待设计", "在途", "待核销"]
 
-/** 轻通道轮次行标记（单源——LIGHT-CHANNEL.md §2.3 开轮挂账 ∥ §2.8 闸凭据 ∥ §2.5 核销标记门
- *  判据三面同一字面；消费面 = `agent/light-round.mjs`（经 `ledger.mjs` re-export 动态解构——
- *  W8 契约②零新静态边）∥ `ledger-cmd.mjs` 核销标记门）。 */
-export const ROUND_MARKER = "收尾链待跑"
-
 /** 老化阈值（天——口径 = 需求档；消费面 = `buildScan`（展示，`days` 可覆盖）+ `ledgerQuery` 逐行
  *  `aged`（查询面，`now` 可注入））。2026-10-07 批 ledger-tool：自 `ledger.mjs` 迁入（枚举常量档单源
  *  ——`ledgerQuery` 计算面直引本档，消 `ledger-cmd ↔ ledger.mjs` 新环；`ledger.mjs` 同名 re-export
  *  保公共面零变——LEDGER.md §13.4）。 */
 export const AGING_DAYS = 30
 
-/** `evidence` 软上限（字——设计档 `LEDGER.md` §5 P4 读数面单源）：超限**只出读数，不拒写**
- *  （软上限非闸门——用户裁定「无限机检反感」；读数面 = `query` 逐行 `evidenceOversize` ∥
- *  `count` 回报）。 */
-export const EVIDENCE_SOFT_LIMIT = 300
+/** `evidence` 判为太长的上限（字——设计档 `LEDGER.md` §5 P4 读数面单源）：过了这条线即判为太长，
+ *  但**只出读数，不拒写**（读数非闸门——用户裁定「无限机检反感」；读数面 = `query` 逐行
+ *  `evidenceTooLong` ∥ `count` 回报）。 */
+export const EVIDENCE_TOO_LONG_MAX = 300
 
 /** 台账库结构版本（N2 标记**单源**——`PRAGMA user_version` 落标：写面开库 `v < 本值 ⇒ 置`；
  *  读面如实回读（旧库未标 = 0）；结构变更（新列 / 新表）同步升号——2026-10-03 read-data-interface 批。
  *  2 = `resume_when` 可空列（设计档 §3.4 P5）。 */
 export const LEDGER_SCHEMA_VERSION = 2
 
-/** 六态允许迁移表（ledgerUpdate 迁移前判，不在表内 → 拒——规格 ②.2；设计档 §2.1）。 */
+/** 六态允许迁移表（ledgerUpdate 迁移前判，不在表内 → 拒——规格 ②.2；设计档 §2.1）。
+ *  2026-10-27 批（三链统一）补两条边：
+ *  - `待讨论 → 在途`：建档事务的必经一步（新建行只能先 INSERT `待讨论`——`在途` 被 DDL 咬合 CHECK 强制
+ *    非空指针；落档后才迁 `在途` 并写指针。没有这条边，`batch create` 写不出来）；
+ *  - `待核销 → 在途`：重开回收（批档重开 ⇒ 行回工作位）。六态唯一的回退边，人面出路与机器径同一条。 */
 export const ALLOWED_MIGRATIONS = {
-  "待讨论": ["待设计", "已废弃"],
+  "待讨论": ["待设计", "在途", "已废弃"],
   "待设计": ["在途", "已废弃"],
   "在途": ["待核销", "已废弃"],
-  "待核销": ["已核销", "已废弃"],
+  "待核销": ["已核销", "在途", "已废弃"],
   "已核销": ["已废弃"],
   "已废弃": [],
 }
@@ -238,8 +239,8 @@ function markSchemaVersion(db) {
  *  **只读态**（readOnly=true——读面专用）：只读句柄 + 零 DDL / ALTER + items 探针（见 openReadOnly）；
  *  如实副作用：旧库（缺 executor 列）**读**不再自动补列——补列归写面开库；读出行缺列按 null 归一。
  *  「目录不存在」的真错照抛（fail-loud——先于推导，文案逐字零改）。
- *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：工具面传 `ctx.agent.cwd`；
- *  缺省 = `process.cwd()`（CLI / 进程锚 = 会话锚的调用面不必传）。 */
+ *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：工具面传 `ctx.agent.cwd`（**必传**；
+ *  缺则该值缺失即失败，不落 `process.cwd()`——进程工作目录不是界）。 */
 export function openLedger(cwd, { create = false, readOnly = false, boundary } = {}) {
   const start = resolve(cwd ?? ".")
   if (!existsSync(start)) {

package/ledger-migrate.mjs

@@ -98,9 +98,9 @@ function fromKeyRefusal(fromKeys, dir) {
   return null
 }
 
-/** 迁移计划（dry-run / confirm 共用）。cwd 口径 = 写门口径 2 同一子表达式（根推导单源 `resolveLedgerRoot(cwd)?.root` ∨ 兜底）——与实开库（`openLedger`）同源。 */
+/** 迁移计划（dry-run / confirm 共用）。cwd 口径 = 写门口径 2 同一子表达式（根推导单源 `resolveLedgerRoot(cwd, cwd)?.root` ∨ 兜底）——与实开库（`openLedger`）同源。界 = 目标自身（不再向上找——同 `findProject` 形）。 */
 export function planLedgerMigration(cwd, { fromKeys = [] } = {}) {
-  const projectRoot = resolveLedgerRoot(cwd)?.root ?? resolve(cwd ?? ".")
+  const projectRoot = resolveLedgerRoot(cwd, cwd)?.root ?? resolve(cwd ?? ".")
   const dir = ledgerDirPath()
   const targetKey = ledgerKey(projectRoot)
   const targetPath = join(dir, `${targetKey}.db`)
@@ -194,7 +194,7 @@ export function runLedgerMigrate(args, { cwd = process.cwd(), out = console.log,
   // 步 3 单事务迁入：BEGIN → 逐行 INSERT（重发新 id）→ 事务内读回核验 → COMMIT；失败 ⇒ ROLLBACK。
   const report = { version: 1, batch, at: now.toISOString(), projectRoot: plan.projectRoot, targetKey: plan.targetKey, targetPath: plan.targetPath, targetCreated: !targetExists, sources: [], skippedRows: [], flags: plan.flags, recycled: [], kept: [] }
   let db
-  try { db = openLedger(plan.projectRoot, { create: true }) } catch (e) { err(`Refused: 目标库不可开（${e.message}）。`); return 1 }
+  try { db = openLedger(plan.projectRoot, { create: true, boundary: plan.projectRoot }) } catch (e) { err(`Refused: 目标库不可开（${e.message}）。`); return 1 }
   try {
     db.exec(`PRAGMA busy_timeout = ${Math.max(0, Math.floor(busyMs))}`)
     const existing = readRows(db)
@@ -255,7 +255,7 @@ export function runLedgerMigrate(args, { cwd = process.cwd(), out = console.log,
 }
 
 /** ③ 审计（只读——零删改）：逐 `*.db` 出 `{键, 文件, 大小, mtime, 行数, 状态分布, 定性}`；归因 = **候选根集合**（锚项目 + `--root`）的变体键匹配（sha1 不可逆——只做候选生成）。 */
-export function auditLedgerDir({ cwd = process.cwd(), roots = [], dir = ledgerDirPath() } = {}) {
+export function auditLedgerDir({ cwd, roots = [], dir = ledgerDirPath() } = {}) {
   let names = []
   try { names = readdirSync(dir).filter((n) => n.endsWith(".db")).sort() } catch { /* 不可读 ⇒ 空报告 */ }
   const anchorKeys = new Set()

package/ledger-read.mjs

@@ -34,28 +34,30 @@ function exportRow(r, full) {
 }
 
 /** 单项目读（**两开均只读态**——版本探针开 + 行集开，§2.3）：库不在 / 非台账库 ⇒ null（项目不出项）。
- *  不可读（坏档）⇒ 抛（单范围 = 读错转 exit 1；族范围 = 调用侧捕获跳过）。 */
-function readProject(root, full) {
-  const probe = openLedger(root, { readOnly: true })
+ *  不可读（坏档）⇒ 抛（单范围 = 读错转 exit 1；族范围 = 调用侧捕获跳过）。
+ *  `boundary` = 上溯上界（会话锚）——**必传**：缺值即当场失败（不再落 `process.cwd()`——那正是台账 #1834
+ *  的静默空账：进程 cwd 与目标项目不同时 `openLedger` 判越界 ⇒ 返回 null「该项目没有台账」，与真无库不可区分）。 */
+function readProject(root, full, boundary) {
+  const probe = openLedger(root, { readOnly: true, boundary })
   if (!probe) return null
   let schemaVersion
   try { schemaVersion = Number(probe.prepare("PRAGMA user_version").get().user_version ?? 0) } finally { probe.close() }
-  const rows = ledgerQuery({ cwd: root })
+  const rows = ledgerQuery({ cwd: root, boundary })
   return { root, name: basename(root), schemaVersion, rows: rows.map((r) => exportRow(r, full)) }
 }
 
 /** 统一序列化单源（N1——两出口共用；载荷 = §3.2 冻结形）。
  *  单范围 = 当前项目一项；`family=true` = 族内发现序逐项（不可读跳过——余者照常）。 */
 export function ledgerExport({ cwd, family = false, full = false } = {}) {
-  const anchor = cwd ?? process.cwd()
+  const anchor = cwd
   if (!family) {
-    const derived = resolveLedgerRoot(anchor)
-    const item = derived ? readProject(derived.root, full) : null
+    const derived = resolveLedgerRoot(anchor, anchor)
+    const item = derived ? readProject(derived.root, full, anchor) : null
     return { projects: item ? [item] : [] }
   }
   const projects = []
   for (const p of discoverFamily(anchor).projects) {
-    try { const item = readProject(p.root, full); if (item) projects.push(item) } catch { /* 不可读跳过 */ }
+    try { const item = readProject(p.root, full, anchor); if (item) projects.push(item) } catch { /* 不可读跳过 */ }
   }
   return { projects }
 }

package/ledger-surface.mjs

@@ -14,7 +14,7 @@ import { ledgerDirPath } from "./ledger-db.mjs"
 /** 单次扫描（直驱面——timer 包装见 `startLedgerSurface`）。**async**（F-LX1：await 判活解析——
  *  LEDGER.md §7.3.1 ④ 读面不阻塞事件循环）。 */
 export async function runLedgerScan({ state, agent = null, anchor = null, render = () => {} } = {}) {
-  const base = anchor ?? agent?.cwd ?? process.cwd()
+  const base = anchor ?? agent?.cwd
   const family = discoverFamily(base)
   const scans = []
   for (const p of family.projects) {

package/ledger-tools.mjs

@@ -24,10 +24,10 @@ const ptrPath = (v) => {
 }
 
 /** 会话锚供值面（**单源**——`cwdOf` 的缺省起点与上溯上界（`boundary`）同一表达式）：
- *  `ctx.agent.cwd` > `ctx.cwd` > 进程 cwd。界 = 会话锚（设计档 §3.8「界（单源）· 两面两界」）——
+ *  `ctx.agent.cwd` > `ctx.cwd`（零进程缺省：工具面拿不到给值时当场失败，不换界）。界 = 会话锚（设计档 §3.8「界（单源）· 两面两界」）——
  *  工具面传给 `resolveLedgerRoot` / `openLedger` 的上界恒取本值，不取 `process.cwd()`（desktop / VSC
  *  宿主下两者不同：会话锚才是「不能跑到工作目录以外去」的那道界）。 */
-const anchorOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
+const anchorOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd
 
 /** 工具 cwd 供值面：**起点 = 动作目标路径**（`docs/core/requirements/ENGINEERING-MODE-V2-SPEC-MANIFEST.md:72`
  *  「参数按用点解析——动作作用于哪个项目的路径，就取那个项目的档」）。
@@ -189,9 +189,9 @@ const ACTION_SPECS = {
       properties: {
         cwd: { type: "string", description: CWD_DESC },
         id: { type: "number", description: "条目 id（与 batch 恰携其一）" },
-        batch: { type: "string", description: "批档指针（与 id 恰携其一）——批级批量结算：只销已到 待核销 的行；待讨论 / 待设计 点名跳过（追认核销不入批量面）" },
-        status: { type: "string", enum: ["已核销", "已废弃"], description: "目标态（勾销 / 追认核销 / 撤回）——携 batch 时可不给（缺省 = 勾销单值），给了只能是 已核销" },
-        evidence: { type: "string", description: "最小证据行（可选；传入 = 追加缺省——旧值非空 ⇒ 拼 `旧｜新`（「｜」零空格）、旧空直写；新值全空白 ⇒ 拒；覆盖 = 与 `evidenceReplace: true` 同传。追认核销面判结果值须非空：缺 / 全空白 ⇒ 拒）" },
+        batch: { type: "string", description: "批档指针（与 id 恰携其一）——批级批量结算：只销已到 待核销 的行；待讨论 / 待设计 点名跳过（须先 update 到 在途 认领）；在途 点名跳过（不可跳）" },
+        status: { type: "string", enum: ["已核销", "已废弃"], description: "目标态（勾销 / 撤回）——携 batch 时可不给（缺省 = 勾销单值），给了只能是 已核销" },
+        evidence: { type: "string", description: "最小证据行（可选；传入 = 追加缺省——旧值非空 ⇒ 拼 `旧｜新`（「｜」零空格）、旧空直写；新值全空白 ⇒ 拒；覆盖 = 与 `evidenceReplace: true` 同传）" },
         evidenceReplace: { type: "boolean", description: "覆盖旗（布尔）：与 evidence 同传 = 整段替换（旧文零保留）；缺省 / false = 追加；旗独传（无新文）⇒ 拒" },
       },
       additionalProperties: false,
@@ -237,7 +237,7 @@ const UNION_PARAMETERS = {
     board: { type: "string", description: "归属板块（需求档文档名；add 可空 / update 缺省 = 不变 / query 过滤）" },
     req_doc: { type: "string", description: "需求档指针（add 可空 / update 缺省 = 不变）" },
     task_book: { type: "string", description: "任务书指针（add 可空 / update 缺省 = 不变；在途 / 待核销必填——咬合 CHECK）" },
-    evidence: { type: "string", description: "最小证据行（add 可空；update / close 传入 = 追加缺省——旧空直写、旧非空拼 `旧｜新`（「｜」零空格）、新值全空白 ⇒ 拒；覆盖 = 与 `evidenceReplace: true` 同传；update 缺省 = 不变 / close 缺省 = 判行值；追认核销须非空）" },
+    evidence: { type: "string", description: "最小证据行（add 可空；update / close 传入 = 追加缺省——旧空直写、旧非空拼 `旧｜新`（「｜」零空格）、新值全空白 ⇒ 拒；覆盖 = 与 `evidenceReplace: true` 同传；update 缺省 = 不变 / close 缺省 = 判行值）" },
     evidenceReplace: { type: "boolean", description: "覆盖旗（布尔）：与 evidence 同传 = 整段替换；缺省 / false = 追加；旗独传（无新文）⇒ 拒（update / close）" },
     trigger: { type: "string", enum: ["归批", "条件", "认账不排期"], description: "技术待办触发（add / update 可空 / query 过滤）" },
     resume_when: { type: "string", description: "复启条件句（add / update 可空；值非空——空串 / 全空白 ⇒ 拒；`trigger=条件` 行的一句话条件 + 可选锚 `@YYYY-MM-DD` ∥ `@事件件名`）" },
@@ -305,14 +305,14 @@ function makeLedgerTool(actions, { readonly = false, writeFace = false } = {}) {
             executorSessionId = getSessionId()
           }
           // 批级批量（§3.3）——`batch` 与 `id` 恰携其一（守卫 P7 已先裁）
-          if (batch != null) return JSON.stringify({ ...ledgerUpdateBatch({ cwd: target, batch, patch, executorSessionId, boundary: anchor }) })
-          return JSON.stringify({ ...ledgerUpdate({ cwd: target, id, patch, executorSessionId, boundary: anchor }) })
+          if (batch != null) return JSON.stringify({ ...ledgerUpdateBatch({ cwd: target, batch, patch, executorSessionId, boundary: anchor, agent: ctx?.agent }) })
+          return JSON.stringify({ ...ledgerUpdate({ cwd: target, id, patch, executorSessionId, boundary: anchor, agent: ctx?.agent }) })
         }
         case "close": {
           const target = startOf(ctx, anchor, rest.cwd, rest.batch, rest.task_book)
           // 批级批量结算（§3.3——勾销径）
-          if (rest.batch != null) return JSON.stringify({ ...ledgerCloseBatch({ cwd: target, batch: rest.batch, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor }) })
-          return JSON.stringify({ ...ledgerClose({ cwd: target, id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor }) })
+          if (rest.batch != null) return JSON.stringify({ ...ledgerCloseBatch({ cwd: target, batch: rest.batch, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor, agent: ctx?.agent }) })
+          return JSON.stringify({ ...ledgerClose({ cwd: target, id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor, agent: ctx?.agent }) })
         }
         case "query": {
           const target = startOf(ctx, anchor, rest.cwd, rest.task_book)

package/ledger-variant-notice.mjs

@@ -35,7 +35,7 @@ export function _resetLedgerVariantNoticeForTest() { noticeChecked = false }
  * @param {{cwd?: string, dir?: string, locale?: string, exists?: (p: string) => boolean}} [opts]
  * @returns {string|null} 单行文案 / null
  */
-export function ledgerVariantNotice({ cwd = process.cwd(), dir = ledgerDirPath(), locale = "en", exists = defaultExists } = {}) {
+export function ledgerVariantNotice({ cwd, dir = ledgerDirPath(), locale = "en", exists = defaultExists } = {}) {
   if (noticeChecked) return null
   noticeChecked = true
   try {