@@ -318,6 +318,14 @@ const READ_INVENTION_BASELINE_PATH = join(
  * choice is between paying for those 36 and giving this map a per-site scope
  * the way `FAILURE_PROPAGATION_SITES` already scopes the other vocabulary. That
  * is a design call, and it is deliberately not taken here.
+ *
+ * ## A second reader: the dispatch derivation (#23584)
+ *
+ * `scripts/pm/dispatch-gates.mjs` reads this table's KEYS, by its name, to tell
+ * a card whose file holds a catch and one of these callees to run this gate
+ * (`guardsADurabilityCriticalCall`). A key added here reaches that lead with
+ * nothing else to edit. Renaming the table, or spelling a key as anything but
+ * a quoted word, makes that tool refuse loudly until its reader moves too.
  */
 const DURABILITY_CRITICAL_CALLEES = new Map([
     [
 
@@ -866,6 +866,15 @@ export const ESCAPABLE_LITERAL_LEDGER_ROWS = Object.freeze([
  *     row moving off REFUSE-WIDE, which takes a ruling. ⛔ Growing the gate's
  *     derivation rules does NOT qualify, and ⛔ neither does this predicate
  *     going quiet on a card, for the reason given above.
+ *   - durability-seam entry: when the durability guard's own source declares
+ *     the population its log-level rule walks in a form this derivation can
+ *     read, the ordinary path match names it and this entry is redundant. Today
+ *     that population is the bare package root, so it would take a ruling that
+ *     moves that root off the wide-population channel. ⛔ Growing the guard's
+ *     DURABILITY_CRITICAL_CALLEES does NOT qualify: the predicate already reads
+ *     that table, so a new callee widens this entry's net and does nothing to
+ *     let a path name the gate. ⛔ Neither does this predicate going quiet on a
+ *     card, for the reason given under the error-code entry.
  *   - root-program entry: when the gate's own source names its root population
  *     in a form this derivation can read — a positive literal, or a generated
  *     manifest of the resolved program — the ordinary path match names it and
@@ -990,6 +999,16 @@ export const CHANGE_KIND_ROWS = [
       },
     ],
   },
+  {
+    kind: 'adds or edits a file holding a catch clause and a durability-critical callee the durability guard declares (judged from CONTENT — no path derivation can name this gate)',
+    matches: 'durability-seam',
+    gates: [
+      {
+        name: 'check:durability-log-level',
+        why: 'it walks every non-test TypeScript source under the package root for a catch whose try calls an operation it declares durability-critical (a write, a DDL step, a store initialisation: the names in its DURABILITY_CRITICAL_CALLEES table, which this lead reads rather than copies), and fails when that catch logs below error without rethrowing or handing the failure to the caller. A counter-guarded summary that reaches error only through an optional call fails it too, and so does a declared propagation site that no longer excuses anything. This is a gate no path derivation can name for most of that population: its log-level walk is the bare package root, which the wide-population ruling keeps out of every matched column, and the only roots it spells are the three its read-seam rule walks, so it scored silent for every other card and PR #23567 paid a CI round trip for that silence (#23584). It needs NO build, being one AST pass over the whole tree in about six seconds, and it names the file, the catch line and the guarded callee. Repair by logging at error with the CONSEQUENCE and the FIX in the first line, by rethrowing, or by handing the failure to the caller through a callee its propagation vocabulary declares, which the checker then proves every path out of the catch reaches. ⛔ Never by `logger.error?.(…)`, which prints nothing against a sink with no error, and ⛔ never by baselining correct code: an entry in its shrink-only baseline means a real unfixed degradation. ⚠ This lead fires on any file holding both a catch clause and a declared callee name, not only one whose seam changed, for the trade the vocabulary entry above states: the wasted run is one cheap gate and the miss is a CI round trip',
+      },
+    ],
+  },
 ];
 
 /**
 
@@ -446,7 +446,7 @@ import {
 // this constant, so a repo that ever renumbered the class would move this tool
 // with it instead of leaving a stale 3 behind in a second copy (#17204).
 import { EXIT_PREREQUISITE_NOT_MET } from '../import-prerequisite.mjs';
-import { blank, maskComments, scanSource } from '../js-comment-mask.mjs';
+import { blank, maskComments, maskCommentsAndLiterals, scanSource } from '../js-comment-mask.mjs';
 import { invokedAs, isEntrypoint } from '../invoked-as.mjs';
 // The human-merge line threshold is declared ONCE, in the landing gate; this
 // tool prints the same reading at dispatch time and never carries a second copy.
@@ -10571,6 +10571,172 @@ export function emitsAnHttpStatus(path, readSource = readTrackedSource) {
   return STATUS_STAMP_POSITION.test(masked) || STATUS_DOOR_CALL.test(masked) || STATUS_CONSTANT_BINDING.test(masked);
 }
 
+/**
+ * Does this file hold a `try`/`catch` AND spell a durability-critical callee
+ * the durability guard declares? This is the content trigger for
+ * `check:durability-log-level` (#23584), and the third CONTENT predicate,
+ * beside the code and status predicates above.
+ *
+ * ## Why no path derivation names this gate
+ *
+ * The guard runs two rules. Its read-seam rule walks three package source
+ * roots that it spells as literals, so a card touching those already reaches
+ * the matched column by path. Its log-level rule walks the bare package root
+ * and admits every non-test `.ts` source under it: 3206 tracked files at
+ * 16abea884, which is 34.8% of the files under that root. Four sibling gates
+ * walk that root the same way, and the bare-root ledger records each of them
+ * REFUSE-WIDE in `CENSUS_REFUSE_WIDE`. The wide-population ruling (decision
+ * batch #43) keeps such a root out of the matched column and out of
+ * `--commands`. So,
+ * for a file outside the three read-seam roots, the guard scored `silent` on
+ * every card. PR #23567 paid a CI round trip for that silence, on the
+ * `saveMetaItem` seam in the runtime's automation domain.
+ *
+ * ## What it matches, and why the vocabulary is READ rather than copied
+ *
+ * A log-level finding needs two things in ONE file. The first is a catch
+ * clause. The second is a call, in that clause's `try`, that resolves to a name
+ * in the guard's `DURABILITY_CRITICAL_CALLEES`. The guard resolves that call
+ * through the call's own spelling, a `const` alias or a `.call`/`.apply`/`.bind`
+ * adapter, and every one of those spells the name somewhere in the same file. So
+ * the two limbs read those two facts, and neither one grades the catch:
+ *
+ *   - CATCH CLAUSE: the keyword followed by its binding or its block. A promise
+ *     `.catch(` is not a clause and the guard never judges one.
+ *   - VOCABULARY: any declared callee name, as a whole word, anywhere in the
+ *     comment-masked source. An import specifier and a `const` alias count.
+ *
+ * The names come from the guard's own source, from the file its discovered
+ * family resolves to. They are never mirrored here. A callee added to that
+ * table is in this net on the next run, and nothing here has to move. The read
+ * keys on the table's NAME. A guard that renames the table, or stops spelling
+ * its keys as quoted words, makes this THROW, naming both. That is the loud
+ * direction, the same contract `rootTsconfigExcludeEntries` states. The read
+ * runs only for a non-test TypeScript path that already holds a catch clause.
+ * A card touching no such file never pays for it and never meets the throw.
+ *
+ * ## Measured, so a widening or narrowing has a number to beat
+ *
+ * At 16abea884, over 3441 non-test TypeScript files:
+ *
+ *   - THIS predicate matches 43 (1.2%). Every one is inside the guard's own
+ *     population. The guard's `--list` reports 46 log-level seams in 28 files,
+ *     and all 28 match, so recall over what this rule can fail on is complete.
+ *     28 of the 43 hold a seam (65%).
+ *   - A catch clause ALONE matches 705 (20.5%), at 4% precision. Over the last
+ *     300 first-parent commits on main, judged against today's content of the
+ *     paths each touched, it fires for 169 (56.3%) against 72 (24.0%) for this
+ *     predicate. That is the REFUSE-WIDE trade under another name, so this
+ *     entry declines it.
+ *
+ * The false-positive trade is the code predicate's. One wasted run costs about
+ * six seconds of a gate that needs no build. A miss costs a CI round trip.
+ *
+ * ## What it cannot see, said out loud
+ *
+ * A file with nothing on disk answers false, as in both predicates above. ⛔
+ * Do not close that by falling back to a path. One more shape can red the guard
+ * with no vocabulary name left in the file: a diff that deletes the last
+ * declared call from a function named in `FAILURE_PROPAGATION_SITES`, which
+ * leaves that entry stale. One such entry sits outside the read-seam roots
+ * today. The edit that strands it removes the very token this predicate reads,
+ * and the guard's own failure text names the entry to delete.
+ */
+export const DURABILITY_SEAM_GATE = 'check:durability-log-level';
+const DURABILITY_CALLEE_TABLE = 'DURABILITY_CRITICAL_CALLEES';
+const DURABILITY_CATCH_CLAUSE = /(?<!\.\s*)\bcatch\s*[({]/;
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+
+/**
+ * The KEYS of `const NAME = new Map([...])` in a module's source, in
+ * declaration order. Null when the module declares no such table.
+ *
+ * Bracket depth is counted on the comment-and-literal mask, so a bracket
+ * inside a reason string or a comment opens nothing. Each tuple's key is then
+ * read out of the ORIGINAL source between its quote delimiters, which that mask
+ * keeps. A tuple whose key is not a quoted identifier THROWS: the table's shape
+ * has moved, and returning fewer names would narrow the predicate silently.
+ *
+ * @param {string} source
+ * @param {string} name
+ * @returns {string[] | null}
+ */
+export function declaredMapKeys(source, name) {
+  const code = maskCommentsAndLiterals(source);
+  const decl = new RegExp(`\\b(?:const|let|var)\\s+${name}\\s*=\\s*new\\s+Map\\s*\\(\\s*\\[`).exec(code);
+  if (!decl) return null;
+  const keys = [];
+  let depth = 1;
+  for (let i = decl.index + decl[0].length; i < code.length && depth > 0; i++) {
+    const c = code[i];
+    if (c === ']' || c === ')' || c === '}') {
+      depth -= 1;
+      continue;
+    }
+    if (c !== '[' && c !== '(' && c !== '{') continue;
+    depth += 1;
+    if (c !== '[' || depth !== 2) continue;
+    const lead = /^\s*(['"`])/.exec(code.slice(i + 1, i + 200));
+    const close = lead ? code.indexOf(lead[1], i + 1 + lead[0].length) : -1;
+    const key = close > 0 ? source.slice(i + 1 + lead[0].length, close) : null;
+    if (key === null || !IDENTIFIER.test(key)) {
+      throw new Error(
+        `dispatch-gates: an entry of ${name} has no quoted identifier as its key ` +
+          `(${JSON.stringify(source.slice(i, i + 60))}), so its callee names cannot be read`,
+      );
+    }
+    keys.push(key);
+  }
+  return keys;
+}
+
+/**
+ * The guard's declared durability-critical callee names, read once per process
+ * from the file `DURABILITY_SEAM_GATE`'s discovered family resolves to.
+ */
+let durabilityCallees = null;
+export function durabilityCriticalCallees(families = null) {
+  if (!families && durabilityCallees) return durabilityCallees;
+  const entry = (families ?? discoverFamilies()).byCheck.get(DURABILITY_SEAM_GATE);
+  if (!entry) {
+    throw new Error(
+      `dispatch-gates: no workflow runs ${DURABILITY_SEAM_GATE} any more, so the durability-seam change kind cannot read ` +
+        `${DURABILITY_CALLEE_TABLE}. Re-point DURABILITY_SEAM_GATE at the gate's new name, or delete the kind with the gate`,
+    );
+  }
+  const names = [];
+  for (const file of entry.files ?? []) {
+    const source = readTrackedSource(file);
+    const keys = source === null ? null : declaredMapKeys(source, DURABILITY_CALLEE_TABLE);
+    if (keys) names.push(...keys);
+  }
+  if (names.length === 0) {
+    throw new Error(
+      `dispatch-gates: ${DURABILITY_SEAM_GATE} resolves to ${(entry.files ?? []).join(', ') || 'no file'}, and none of them ` +
+        `declares a non-empty ${DURABILITY_CALLEE_TABLE} map, so the durability-seam change kind has no vocabulary to read. ` +
+        'The table was renamed or reshaped: move this reader with it',
+    );
+  }
+  if (!families) durabilityCallees = names;
+  return names;
+}
+
+export function guardsADurabilityCriticalCall(path, readSource = readTrackedSource, callees = durabilityCriticalCallees) {
+  if (!/\.[cm]?tsx?$/.test(path) || /\.d\.[cm]?ts$/.test(path)) return false;
+  if (isTestFilePath(path)) return false;
+  const source = readSource(path);
+  if (source === null || source === undefined) return false;
+  // Masked for the code predicate's reason: a catch or a callee DISCUSSED in
+  // prose is neither a clause nor a call.
+  const masked = maskedComments(source);
+  if (!DURABILITY_CATCH_CLAUSE.test(masked)) return false;
+  const names = callees();
+  // An empty alternation matches the empty string at every word boundary, so
+  // an empty vocabulary must answer false here rather than reach every file.
+  if (names.length === 0) return false;
+  return new RegExp(`\\b(?:${names.map((n) => n.replace(/\$/g, '\\$')).join('|')})\\b`).test(masked);
+}
+
 /**
  * Is this path inside the ROOT package's tsc program — the population behind
  * the `@objectstack/spec-monorepo` entry of `check:type-check-debt`?
@@ -10846,6 +11012,7 @@ const CHANGE_KIND_PREDICATES = Object.freeze({
   'root-ts-program': (path) => isInRootTsProgram(path, rootTsProgramExcludedDirs()),
   'error-code-literal': stampsAnErrorCodeLiteral,
   'http-status-emit': emitsAnHttpStatus,
+  'durability-seam': guardsADurabilityCriticalCall,
 });
 
 export function bindChangeKindRows(rows, predicates = CHANGE_KIND_PREDICATES) {
@@ -11619,13 +11786,18 @@ export function residueLines(
 
 /**
  * The single source of truth for the model tier the PM lane's governance
- * reads — clause ②'s CONTRACT-REVIEW tier: the tier the clause-② REVIEW runs
- * at, both halves of it — the spec and skills lanes' review of every round
- * they deliver (a card that WIDENS a published accept set or the public
- * surface is spec-lane work, whichever seat found it; a card that only
- * NARROWS one is not, and owes one contract-review-tier review before the
- * queue while staying in its lane) and the `Served-tier:` line every
- * `## Contract review` record carries. The
+ * reads — clause ②'s CONTRACT-REVIEW tier: the tier a contract review runs at
+ * when the face that made it owed is a published schema or governed rules
+ * text, and the `Served-tier:` line that review's `## Contract review` record
+ * carries. The review is owed by SURFACE, never by lane, and served at the
+ * tier of the face that made it owed (ruling record 6159870311, letter B′
+ * with C): `reviewFace` in `record-recognisers.mjs` holds the mapping, and a
+ * review owed ONLY by a `Clause-②: yes` declaration is served at
+ * `TIER_DEFAULT` by the lane seat, as its own review of record. No lane names
+ * this tier. As the `--tier` note spells it, a card that WIDENS a published
+ * accept set or the public surface is spec-lane work, whichever seat found
+ * it; a card that only NARROWS one is `Clause-②: no`, stays in its lane, and
+ * owes one contract-review-tier review before the queue. The
  * BUILD of such a card is at the default judgment tier, so
  * this constant is a review tier and never a dispatch mandate. Declared HERE
  * and only here, as a constant, so a model upgrade is a one-line change in one