claude-mem-lite 6.30.1 → 6.30.3

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.30.1",
+      "version": "6.30.3",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.30.1",
+  "version": "6.30.3",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/README.md

@@ -362,7 +362,7 @@ rollback recipe under "Trust model per install path".
 schema-version change: 6.20.0 still opens the database after this release has. Pin
 `claude-mem-lite@6.20.0` before upgrading to avoid the move; after it, 6.20.0 names these
 directories by their old ids again, so their moved rows are listed only with
-`--project <new id>`.
+`--project=<new id>`.
 
 - **Which projects.** Every character outside ASCII letters, digits and `_.-` used to become `-`,
   so `~/projects/博客` and `~/projects/商城` were both `projects----` and shared one memory.
@@ -374,7 +374,7 @@ directories by their old ids again, so their moved rows are listed only with
   directory using the old id, the project takes everything under it, deferred items and session
   history included. Otherwise only the memories whose file paths lie inside the directory move;
   the rest stay under the old id. A one-time notice says what moved and how to list what stayed
-  (`claude-mem-lite recent 50 --project <old id>`).
+  (`claude-mem-lite recent 50 --project=<old id>`).
 - **Not in this release:** directories with the same parent and name in different repositories
   (`~/a/packages/api` and `~/b/packages/api`) still share one id.
 - **Also changed:** two sessions open in one project keep separate memory sessions (handoffs,

package/README.zh-CN.md

@@ -277,7 +277,7 @@ README "Trust model per install path" 一节的回退步骤操作。
 
 **名字不是纯 ASCII 的项目会换一个新标识，它们存下的内容会搬一次。** 没有 schema 版本变更：
 本版本打开过的数据库，6.20.0 仍能打开。想避免搬迁，请在**升级之前**固定 `claude-mem-lite@6.20.0`；
-升级之后再回退，6.20.0 会按旧标识称呼这些目录，搬走的行只能用 `--project <新标识>` 列出。
+升级之后再回退，6.20.0 会按旧标识称呼这些目录，搬走的行只能用 `--project=<新标识>` 列出。
 
 - **哪些项目。** 以前 ASCII 字母、数字和 `_.-` 以外的字符都变成 `-`，所以 `~/projects/博客` 和
   `~/projects/商城` 都是 `projects----`，共用一份记忆。现在任何文字的字母、组合符和数字都会保留
@@ -285,7 +285,7 @@ README "Trust model per install path" 一节的回退步骤操作。
   组合符或数字，或有基本多文种平面以外的字符（如 `🚀`）时，标识会变。
 - **项目第一次启动会话时搬迁数据。** 如果旧标识下没有任何文件路径显示另一个同样使用该旧标识的目录，
   就把旧标识下的全部内容搬过来，包括待办和会话历史。否则只搬文件路径落在本目录里的记忆，其余留在
-  旧标识下。会提示一次搬了什么，以及怎么列出留下的内容（`claude-mem-lite recent 50 --project <旧标识>`）。
+  旧标识下。会提示一次搬了什么，以及怎么列出留下的内容（`claude-mem-lite recent 50 --project=<旧标识>`）。
 - **本版本不包含：** 不同仓库里父目录和目录名都相同的目录（`~/a/packages/api` 与 `~/b/packages/api`）
   仍共用一个标识。
 - **其他变化：** 同一项目同时开两个会话，各自的交接、摘要和未保存的工具记录不再混在一起；会话里的

package/commands/verify.md

@@ -33,7 +33,7 @@ otherwise ask. Always pass that exact name — `export --project` matches loosel
 neighbouring project from a short name.
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" export --project <project> [--from <date>] > <scratch>/memories.json
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" export --project=<project> [--from <date>] > <scratch>/memories.json
 ```
 
 Every row carries `id`, `project`, `type`, `title`, `narrative`, `facts`, `lesson_learned`,
@@ -113,7 +113,7 @@ Write `<scratch>/proposals.json` — a JSON array, one entry per memory to chang
 ## Step 4 — Show the plan and get approval
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project <project>
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project=<project>
 ```
 
 This is a dry run: it validates every entry against the database, writes nothing, prints each
@@ -130,7 +130,7 @@ the old one will be refused.
 Run exactly the command the dry run printed:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project <project> --apply --digest <digest>
+node "${CLAUDE_PLUGIN_ROOT}/cli.mjs" verify-apply <scratch>/proposals.json --project=<project> --apply --digest <digest>
 ```
 
 It refuses if the proposals or the memories changed since the dry run. Otherwise it backs up

package/install.mjs

@@ -478,16 +478,19 @@ export async function dbCheckRemedy(dbPath, err) {
   const remedy = dbUnusableRemedy(dbPath, err);
   if (remedy.kind === 'unknown') return remedy.note;
   if (remedy.kind === 'schema') return `SQLite cannot read the database's schema. ${remedy.note}`;
+  // Both commands start by deleting the -wal and -shm and then replace or move the database file,
+  // under any session still holding the store (D#534). The SessionStart notice says the same before
+  // its copy of the command.
   if (remedy.kind === 'set-aside') {
     return (
-      `No backup snapshot exists beside the database. Set the broken file aside so a fresh ` +
-      `store is created on the next session: ${remedy.command} ` +
+      `No backup snapshot exists beside the database. Once every Claude Code session is closed, ` +
+      `set the broken file aside so a fresh store is created on the next session: ${remedy.command} ` +
       `— memories in that file are not recoverable without a backup.`
     );
   }
   return (
-    `Restore the newest of ${remedy.snapshotCount} backup snapshot(s): ${remedy.command} ` +
-    `— move the broken file aside first if you want to keep it for inspection.`
+    `Restore the newest of ${remedy.snapshotCount} backup snapshot(s) once every Claude Code session ` +
+    `is closed: ${remedy.command} — move the broken file aside first if you want to keep it for inspection.`
   );
 }
 

package/lib/db-unusable.mjs

@@ -229,7 +229,12 @@ export function formatDbUnusableNotice({ dbPath, remedy }) {
       ? `   ${dbPath} exists but SQLite cannot read its schema.`
       : `   ${dbPath} exists but SQLite does not recognise it as a database.`,
   ];
-  if (remedy.command) lines.push(`   ${remedy.command}`);
+  if (remedy.command) {
+    // Before the command: it deletes the -wal and -shm, then replaces or moves the database file,
+    // under any session still holding the store (D#534). doctor says the same.
+    lines.push('   Once every Claude Code session is closed, this one included, run:');
+    lines.push(`   ${remedy.command}`);
+  }
   if (remedy.note) lines.push(`   ${remedy.note}`);
   lines.push(`   Saves and recall are disabled. \`${CLI_INVOKE} doctor\` re-checks.`);
   return lines.join('\n');

package/lib/hook-prune.mjs

@@ -10,7 +10,8 @@
 // path, which must stay cheap and must not drag install.mjs's dependency graph in.
 
 import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { join, dirname, isAbsolute, win32 } from 'node:path';
 
 /**
  * Identify a settings hook as one of OURS (to replace on install / strip on uninstall).
@@ -36,8 +37,13 @@ export function isMemHook(cfg, roots = null) {
 // under `.claude-mem-lite`, the pre-v0.5 `claude-mem-lite`, or a checkout named after it
 // (`claude-mem-lite-main` from a zip), with either separator. A bare substring also took
 // `claude-mem-lite export > ~/backups/…` and `~/tools/claude-mem-lite-prompt-audit.py`, which
-// install and uninstall then deleted.
-const OUR_ENTRY_PATH_RE = /claude-mem-lite[\w.-]*[\\/](?:hook\.mjs|scripts[\\/][\w.-]+\.(?:mjs|js|sh))/;
+// install and uninstall then deleted. The directory name alone still took a user's own
+// `node ~/claude-mem-lite-notes/scripts/fmt.js` (D#479), so the path counts as the launcher's
+// does (isOurEntryPath): its root carries the product, or it names one of our entries and is gone.
+const ENTRY_PATH = String.raw`claude-mem-lite[\w.-]*[\\/](?:hook\.mjs|scripts[\\/][\w.-]+\.(?:mjs|js|sh))`;
+const OUR_ENTRY_PATH_RE = new RegExp(
+  `(?:"([^"]*${ENTRY_PATH})"|([^\\s"]*${ENTRY_PATH})(?=\\s|$))(?:\\s+([\\w-]+))?`,
+);
 
 // The launcher as every install writes it: `<dir>/scripts/hook-launcher.mjs` followed by one of
 // our entry shapes (`hook.mjs <event>` or `scripts/<x>.js|mjs`). Matching the bare file name took
@@ -68,6 +74,16 @@ const OUR_LAUNCHER_SCRIPTS = new Set([
   'pre-agent-inject.js',
   'pre-skill-bridge.js',
 ]);
+// Every scripts/ entry a settings.json hook or hooks/hooks.json has run directly or through the
+// launcher, for a path under a claude-mem-lite* directory that is gone (isOurEntryPath).
+const OUR_ENTRY_SCRIPTS = new Set([
+  ...OUR_LAUNCHER_SCRIPTS,
+  'hook-launcher.mjs',
+  'setup.sh',
+  'post-tool-use.sh',
+  'pre-agent-inject.sh',
+  'pre-tool-recall-bash.sh',
+]);
 
 /**
  * Whether an install root is the product's own: the plugin's `${CLAUDE_PLUGIN_ROOT}`, or a
@@ -85,6 +101,21 @@ function isProductRoot(root) {
   }
 }
 
+// `<root>/hook.mjs <event>` or `<root>/scripts/<x>` under a claude-mem-lite* directory. Either
+// separator, since the install it names may be a Windows one, and `~/` as the user's home.
+function isOurEntryPath(cmd) {
+  const m = OUR_ENTRY_PATH_RE.exec(cmd);
+  if (!m) return false;
+  const raw = m[1] ?? m[2];
+  const path = /^~[\\/]/.test(raw) ? join(homedir(), raw.slice(2)) : raw;
+  if (!isAbsolute(path) && !win32.isAbsolute(path)) return false;
+  if (isProductRoot(path.replace(/[\\/](?:hook\.mjs|scripts[\\/][^\\/]+)$/, ''))) return true;
+  const ours = /[\\/]hook\.mjs$/.test(path)
+    ? OUR_HOOK_EVENTS.has(m[3])
+    : OUR_ENTRY_SCRIPTS.has(path.slice(path.search(/[^\\/]+$/)));
+  return ours && !existsSync(path);
+}
+
 function isOurLauncher(cmd) {
   const m = OUR_LAUNCHER_RE.exec(cmd);
   if (!m) return false;
@@ -198,7 +229,7 @@ export function unconfirmedDeadPrefilters(settings, env = process.env) {
  */
 export function isMemHookCommand(command, roots = null) {
   const cmd = typeof command === 'string' ? command : '';
-  return OUR_ENTRY_PATH_RE.test(cmd) || isOurLauncher(cmd) || isOurPrefilter(cmd, roots);
+  return isOurEntryPath(cmd) || isOurLauncher(cmd) || isOurPrefilter(cmd, roots);
 }
 
 /**

package/lib/maintain-core.mjs

@@ -855,6 +855,9 @@ export function findDuplicates(
     if (!titles[i] || !minhashes[i]) continue;
     for (let j = i + 1; j < recent.length; j++) {
       if (!titles[j] || !minhashes[j]) continue;
+      // mergeDuplicates skips a pair from two projects, so a scan over every project printed
+      // pairs its own command would not merge, and they took slots from real ones (D#464).
+      if (recent[i].project !== recent[j].project) continue;
       if (estimateJaccardFromMinHash(minhashes[i], minhashes[j]) < MINHASH_PRE_THRESHOLD) continue;
       const sim = jaccardSimilarity(titles[i], titles[j]);
       if (sim > SIMILARITY_THRESHOLD) {

package/mem-cli.mjs

@@ -3679,12 +3679,16 @@ async function cmdOptimize(db, args) {
   // the default budget (tasks/project undefined → run-everything). Normalize
   // `--flag=value` into `--flag value` up front so both forms parse identically;
   // the `--execute=` special-case below already anticipated this for one flag.
+  // On/off flags are read as parseArgs and the dispatcher's dry-run check read them (isTrue): after
+  // the split below, `args.includes('--run')` took `--run=false` and `--run false` as a run, which
+  // that check had let through as no write (D#514).
+  const { flags } = parseArgs(args, { track: false });
   args = args.flatMap((a) => {
     const m = /^(--[a-z][a-z-]*)=([\s\S]*)$/.exec(a);
     return m ? [m[1], m[2]] : [a];
   });
-  const run = args.includes('--run');
-  const runAll = args.includes('--run-all');
+  const run = isTrue(flags.run);
+  const runAll = isTrue(flags['run-all']);
   // Sibling-command flag footgun: optimize executes with --run (compress uses
   // --execute, maintain uses positional `execute`). A bare --execute previously fell
   // through to a silent preview, so the user thought they ran a mutation but didn't.
@@ -3697,7 +3701,7 @@ async function cmdOptimize(db, args) {
     );
     return;
   }
-  const verbose = args.includes('--verbose') || args.includes('-v');
+  const verbose = isTrue(flags.verbose) || args.includes('-v');
   // T2-P1-D: --task accepts a single task or a comma-separated list, parity with MCP memOptimizeSchema.tasks.
   const VALID_TASKS = ['re-enrich', 'normalize', 'cluster-merge', 'smart-compress'];
   const taskIdx = args.indexOf('--task');
@@ -3932,15 +3936,16 @@ const MUTATING_FILTER_READS = {
 // A command not in MUTATING_FILTER_READS names here when its run writes (round-2 pre-tag review
 // P3-2: defer drop and fts-check rebuild ignored --dry-run silently; verify-apply --apply is left
 // to its digest, since --apply is verify-apply's own flag and the dispatcher may not read it).
-// A preview is the same command without the flag that makes it write (the user's other flags stay),
-// or another command (`preview`).
+// A preview is the same command without the flag that makes it write, or with its previewing
+// subcommand in place of the writing one (`swap`), so the user's other flags stay (`maintain scan`
+// alone previewed every project, D#514); else another command (`preview`).
 const DRY_RUN_UNREAD = {
   compress: { without: '--execute' },
-  maintain: { preview: 'maintain scan' },
+  maintain: { swap: 'scan in place of execute' },
   optimize: { without: '--run or --run-all' },
-  delete: { preview: null },
+  delete: { without: '--confirm' },
   'activity promote': { without: '--execute' },
-  'activity delete': { preview: null },
+  'activity delete': { without: '--confirm' },
   'import-jsonl': { preview: null, writes: () => true },
   'defer drop': { preview: null, writes: () => true },
   'fts-check': { preview: 'fts-check check', writes: ({ positional }) => positional[0] === 'rebuild' },
@@ -4064,11 +4069,18 @@ async function runDispatch(argv) {
 
   if (Object.hasOwn(DRY_RUN_UNREAD, mutatingKey)) {
     const parsed = parseArgs(cmdArgs, { track: false });
-    const { preview, without, writes } = DRY_RUN_UNREAD[mutatingKey];
+    const { preview, without, swap, writes } = DRY_RUN_UNREAD[mutatingKey];
     if ((mutating ? mutating.writes(parsed) : writes(parsed)) && asksDryRun(parsed.flags['dry-run'])) {
+      const how = without
+        ? `Run it again without ${without} to preview.`
+        : swap
+          ? `Run it again with ${swap} to preview.`
+          : preview
+            ? `Preview with: \`${CLI_INVOKE} ${preview}\`.`
+            : 'It has no preview.';
       fail(
         `[mem] ${mutatingKey} does not read --dry-run — nothing was changed, since the run would have ` +
-          `written. ${without ? `Run it again without ${without} to preview.` : preview ? `Preview with: \`${CLI_INVOKE} ${preview}\`.` : 'It has no preview.'}`,
+          `written. ${how}`,
       );
       return;
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.30.1",
+  "version": "6.30.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.30.1",
+      "version": "6.30.3",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.30.1",
+  "version": "6.30.3",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/schema.mjs

@@ -1704,15 +1704,18 @@ export function ensureDb() {
   try {
     chmodSync(DB_PATH, 0o600);
   } catch {}
-  db.pragma('journal_mode = WAL');
-  // 5000ms matches the MCP server (server.mjs) — 3000ms wasn't enough under realistic
-  // concurrency (parallel CLI saves + a long-running FTS rebuild can push individual
-  // transactions past 3s, triggering SQLITE_BUSY on the third caller).
-  db.pragma(`busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
-  db.pragma('synchronous = NORMAL');
-  db.pragma('foreign_keys = OFF'); // Enabled after dedup migration
 
+  // The pragmas sit inside the try that closes the handle: `journal_mode = WAL` throws on a
+  // damaged WAL, and a handle leaked there was closed by better-sqlite3 at exit, which wrote the
+  // damaged frame into the main file (D#438, D#506).
   try {
+    db.pragma('journal_mode = WAL');
+    // 5000ms matches the MCP server (server.mjs) — 3000ms wasn't enough under realistic
+    // concurrency (parallel CLI saves + a long-running FTS rebuild can push individual
+    // transactions past 3s, triggering SQLITE_BUSY on the third caller).
+    db.pragma(`busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+    db.pragma('synchronous = NORMAL');
+    db.pragma('foreign_keys = OFF'); // Enabled after dedup migration
     const ready = initSchema(db);
     // P1-5: sentinel-gated data cleanups must run on EVERY open (schema.mjs:766).
     // They were extracted out of initSchema into runDeferredCleanups but never
@@ -1726,13 +1729,38 @@ export function ensureDb() {
     }
     return ready;
   } catch (e) {
-    try {
-      db.close();
-    } catch {}
+    closeWithoutCheckpoint(db);
     throw e;
   }
 }
 
+/**
+ * Close a connection whose open failed, without letting the close checkpoint. The last connection
+ * to close a WAL database copies the WAL into the main file first and checks no page, so a failed
+ * open over a damaged frame wrote that frame into the main file (D#506). A read-only connection
+ * that has run a statement holds the shared lock, so the close below is not the last, and a
+ * read-only close never checkpoints; one only opened holds nothing. Counts on the corrupt-WAL
+ * fixture: docs/audits/20261021-d506-wal-recovery-experiments.md, Q1. The statement may fail on
+ * the damaged WAL; it takes the lock all the same. With no guard, the close is the plain
+ * one it always was.
+ */
+function closeWithoutCheckpoint(db) {
+  let guard = null;
+  try {
+    guard = new Database(DB_PATH, { readonly: true, fileMustExist: true });
+    if (busyDeadline !== null) capBusyWaits(guard);
+    guard.pragma('schema_version');
+  } catch {
+    /* no guard, or a read that failed on the damaged WAL and took the lock all the same */
+  }
+  try {
+    db.close();
+  } catch {}
+  try {
+    guard?.close();
+  } catch {}
+}
+
 /**
  * Give the query planner statistics (sqlite_stat1/4) the way SQLite's docs recommend:
  * `PRAGMA optimize=0x10002` analyzes only tables whose indexes have no statistics yet or

package/scripts/setup.sh

@@ -430,16 +430,21 @@ fi
 #    settings.json.
 # CODE_DIR/runtime, same reason: the residue it warns about is stale hook entries in the config
 # home's settings.json — one warning per config home, regardless of where the data lives.
+# The test for a stale hook is cleanup-hooks' classifier, lib/hook-prune.mjs beside this script.
+# A substring of the product name listed a user's own hook kept under ~/.claude-mem-lite/ (D#513).
 RESIDUE_MARKER="$CODE_DIR/runtime/.residue-warned-v2.55$(marker_suffix "$CC_CONFIG_DIR/settings.json" "$CC_DEFAULT_CONFIG_DIR/settings.json")"
 if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" && ! -f "$RESIDUE_MARKER" ]]; then
   SETTINGS="$CC_CONFIG_DIR/settings.json"
   if [[ -f "$SETTINGS" ]]; then
-    SETTINGS_PATH="$SETTINGS" CFG_DIR="$CC_CONFIG_DIR" node -e '
+    HOOK_PRUNE="$(dirname "${BASH_SOURCE[0]}")/../lib/hook-prune.mjs" \
+      SETTINGS_PATH="$SETTINGS" CFG_DIR="$CC_CONFIG_DIR" node -e '
       const fs = require("fs");
-      try {
+      const { pathToFileURL } = require("url");
+      import(pathToFileURL(process.env.HOOK_PRUNE).href).then(({ isMemHookCommand, ourInstallRoots }) => {
         const raw = fs.readFileSync(process.env.SETTINGS_PATH, "utf8");
         const data = JSON.parse(raw);
         const hooks = data.hooks || {};
+        const roots = ourInstallRoots(data);
         const events = Object.keys(hooks);
         const found = [];
         for (const ev of events) {
@@ -447,8 +452,7 @@ if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" && ! -f "$RESIDUE_MARKER" ]]; then
           for (const entry of list) {
             const inner = Array.isArray(entry?.hooks) ? entry.hooks : [];
             for (const h of inner) {
-              const cmd = String(h?.command || "");
-              if (cmd.includes(".claude-mem-lite/") || cmd.includes("claude-mem-lite/scripts") || cmd.includes("claude-mem-lite/hook.mjs")) {
+              if (isMemHookCommand(h?.command, roots)) {
                 found.push(ev);
                 break;
               }
@@ -470,7 +474,7 @@ if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" && ! -f "$RESIDUE_MARKER" ]]; then
           process.stderr.write("       then keep using the plugin install. (One-time warning.)\n\n");
           process.exit(2);
         }
-      } catch {}
+      }).catch(() => {});
     ' || true
   fi
   # Mark the warning as shown regardless of result — silence is fine if no

package/secret-scrub.mjs

@@ -464,35 +464,62 @@ const isEscBreak = (r, u) => u > 0 && r % (2 * u) === u;
 // An unescaped quote at depth u ends the string: r % 2u < u.
 const isStringEnd = (r, u) => u > 0 && r % (2 * u) < u;
 
+// The characters an escaped line acts on: breaks and backslashes; every other character only moves
+// it on. Steps past LINE_STEP_BUDGET of them are searched natively: a line that runs to the end of
+// the text, read once per BEGIN at its depth and once per pass, was 94.6% of the time of the
+// escape-depth shape (D#511). A line at depth 0 keeps the plain loop.
+const ESC_LINE_STOP_RE = /[\n\r\\]/g;
+const LINE_STEP_BUDGET = 32;
+
 /** The line starting at s: its end, and where the next line starts (-1 at the end of the text). */
 function nextLine(text, s, u) {
+  if (u > 0) return nextEscapedLine(text, s, u);
   const n = text.length;
-  let i = s;
-  while (i < n) {
+  for (let i = s; i < n; i++) {
     const ch = text[i];
     if (ch === '\n') return { end: i, next: i + 1 };
     if (ch === '\r') return { end: i, next: text[i + 1] === '\n' ? i + 2 : i + 1 };
-    if (u > 0 && ch === '\\') {
-      let j = i;
-      while (j < n && text[j] === '\\') j++;
-      const r = j - i;
-      const c = text[j];
-      if ((c === 'n' || c === 'r') && isEscBreak(r, u)) {
-        let next = j + 1;
-        if (c === 'r' && text.startsWith('\\'.repeat(u) + 'n', next)) next += u + 1;
-        if (u === 1) {
-          CONCAT_AFTER_RE.lastIndex = next;
-          const m = CONCAT_AFTER_RE.exec(text);
-          if (m) next += m[0].length;
+  }
+  return { end: n, next: -1 };
+}
+
+/** nextLine at break depth u > 0. */
+function nextEscapedLine(text, s, u) {
+  const n = text.length;
+  let i = s;
+  let lim = Math.min(n, s + LINE_STEP_BUDGET);
+  for (;;) {
+    while (i < lim) {
+      const ch = text[i];
+      if (ch === '\n') return { end: i, next: i + 1 };
+      if (ch === '\r') return { end: i, next: text[i + 1] === '\n' ? i + 2 : i + 1 };
+      if (ch === '\\') {
+        let j = i;
+        while (j < n && text[j] === '\\') j++;
+        const r = j - i;
+        const c = text[j];
+        if ((c === 'n' || c === 'r') && isEscBreak(r, u)) {
+          let next = j + 1;
+          if (c === 'r' && text.startsWith('\\'.repeat(u) + 'n', next)) next += u + 1;
+          // The pattern starts with a quote, so no other character can begin a match.
+          if (u === 1 && (text[next] === '"' || text[next] === "'")) {
+            CONCAT_AFTER_RE.lastIndex = next;
+            const m = CONCAT_AFTER_RE.exec(text);
+            if (m) next += m[0].length;
+          }
+          return { end: j - u, next };
         }
-        return { end: j - u, next };
+        i = j + 1;
+        continue;
       }
-      i = j + 1;
-      continue;
+      i++;
     }
-    i++;
+    if (i >= n) return { end: n, next: -1 };
+    ESC_LINE_STOP_RE.lastIndex = i;
+    if (!ESC_LINE_STOP_RE.test(text)) return { end: n, next: -1 };
+    i = ESC_LINE_STOP_RE.lastIndex - 1;
+    lim = Math.min(n, i + LINE_STEP_BUDGET);
   }
-  return { end: n, next: -1 };
 }
 
 /** The line that ends at the break before `ls`, or null when `ls` starts the text or string. */
@@ -534,6 +561,31 @@ function prefixShape(prefix) {
   return new RegExp(`^[ \\t]*${src}`);
 }
 
+const isTagNameCode = (c) =>
+  (c >= 65 && c <= 90) ||
+  (c >= 97 && c <= 122) ||
+  (c >= 48 && c <= 57) ||
+  c === 95 ||
+  c === 58 ||
+  c === 46 ||
+  c === 45;
+
+/**
+ * The length of a closing tag `</name>` (a letter, then up to 40 of `[\w:.-]`) that ends `line` at
+ * q, starting at a or after; 0 when there is none. `/<\/[A-Za-z][\w:.-]{0,40}>$/` on
+ * `line.slice(a, q)`, read from its end: the name is the run of name characters before the `>`,
+ * since a `/` cannot be one of them.
+ */
+function closingTagLength(line, a, q) {
+  if (line[q - 1] !== '>') return 0;
+  let r = q - 1;
+  while (r > a && q - 1 - r <= 41 && isTagNameCode(line.charCodeAt(r - 1))) r--;
+  const len = q - 1 - r;
+  if (len < 1 || len > 41 || r - 2 < a || line[r - 1] !== '/' || line[r - 2] !== '<') return 0;
+  const c = line.charCodeAt(r);
+  return (c >= 65 && c <= 90) || (c >= 97 && c <= 122) ? q - (r - 2) : 0;
+}
+
 /** The judged part of line [s, e): no prefix of the key's shape, no padding, no string quotes. */
 function lineCore(text, s, e, shape) {
   let line = text.slice(s, e);
@@ -555,8 +607,8 @@ function lineCore(text, s, e, shape) {
   // `(?:\\+[rn])*["']…$` retried every start in a backslash run.
   let q = b;
   while (q > a && ' \t+,;)]}'.includes(line[q - 1])) q--;
-  const tag = q > a && line[q - 1] === '>' ? /<\/[A-Za-z][\w:.-]{0,40}>$/.exec(line.slice(a, q)) : null;
-  if (tag) b = q - tag[0].length;
+  const tag = q > a ? closingTagLength(line, a, q) : 0;
+  if (tag) b = q - tag;
   else if (q > a && (line[q - 1] === '"' || line[q - 1] === "'" || line[q - 1] === '`')) {
     q--;
     for (;;) {
@@ -660,6 +712,12 @@ function cutOffKeyEnd(text, b, be) {
   let run = 0;
   while (run < 16 && b - run > ls && isB64Code(text.charCodeAt(b - run - 1))) run++;
   const shape = run >= 16 ? null : prefixShape(text.slice(ls, b));
+  // The first character of the prefix after its spaces and tabs: a shape's match can only start a
+  // line whose first character after spaces and tabs is this one (a digit, `:` and `-` stand for
+  // more, and none of them begins a blank line below).
+  let pl = ls;
+  while (pl < b && (text.charCodeAt(pl) === 32 || text.charCodeAt(pl) === 9)) pl++;
+  const shapeLead = shape ? text.charCodeAt(pl) : -1;
 
   let armors = 0;
   let shorts = 0;
@@ -668,6 +726,32 @@ function cutOffKeyEnd(text, b, be) {
     // Another BEGIN line is never part of this key; stop before reading it whole.
     if (!shape && text.startsWith('-----BEGIN ', next)) break;
     const line = nextLine(text, next, u);
+    // Blank lines read here without lineCore, where the runs a BEGIN reads through spent a third of
+    // their time (D#511). Spaces and tabs, at most one quote or backtick, spaces and tabs: blank
+    // whatever the shape, since a shape that matches takes a prefix of it and lineCore takes leading
+    // blanks, one leading quote and trailing blanks from the rest. Spaces and tabs, at most one
+    // quote, then exactly a closing tag and blanks: blank too, unless the shape can start where the
+    // line does (lineCore takes the tag whole, but a shape could take part of it).
+    const le = line.end;
+    let k = next;
+    while (k < le && (text.charCodeAt(k) === 32 || text.charCodeAt(k) === 9)) k++;
+    const c0 = text.charCodeAt(k);
+    if (k < le && (c0 === 34 || c0 === 39 || c0 === 96)) k++;
+    let blank = k === le;
+    if (!blank && text.charCodeAt(k) === 60 && c0 !== shapeLead) {
+      let e2 = le;
+      while (e2 > k && (text.charCodeAt(e2 - 1) === 32 || text.charCodeAt(e2 - 1) === 9)) e2--;
+      blank = closingTagLength(text, k, e2) === e2 - k;
+    } else if (!blank && k > next && (c0 === 34 || c0 === 39 || c0 === 96)) {
+      while (k < le && (text.charCodeAt(k) === 32 || text.charCodeAt(k) === 9)) k++;
+      blank = k === le;
+    }
+    if (blank) {
+      next = line.next;
+      if (shorts > 0) break;
+      pendingBlank = true;
+      continue;
+    }
     const { core, start, end: coreEnd } = lineCore(text, next, line.end, shape);
     const kind = classify(core);
     next = line.next;