@starci/eslint-canon-be 1.0.1 → 1.2.0

package/module-layering.mjs

@@ -1,16 +1,28 @@
 /**
  * The rules that hold `module-layering.mjs`'s law file, `module-layering.md`.
  *
- * Two rules, both reading import specifiers against the path of the file doing the importing. They
- * are cheap and exact, which is the whole reason they can be `error`.
+ * Five rules, all reading import specifiers, export specifiers, decorators or a filename against
+ * the path of the file being linted. They are cheap and exact -- none of them touches disk -- which
+ * is the whole reason they can be `error`:
+ *   - `must-deep-module-import` / `no-self-module-alias` hold LAYERING-1 and LAYERING-2.
+ *   - `no-folder-reexport` holds LAYERING-5 / Law 7 (no file re-exports a folder).
+ *   - `no-self-global-module` holds the decidable slice of LAYERING-4 / Law 6 (a capability may not
+ *     declare itself `@Global()`; see that rule's own doc comment for what is deliberately still
+ *     left undecided).
+ *   - `no-relative-capability-escape` holds Law 8 (a relative import may not walk out of its own
+ *     capability -- crossing a boundary always goes through the declared public alias).
  *
  * LAYERING-3 (a capability module importing a sibling capability) is NOT here, and the omission is
  * deliberate rather than an oversight: deciding whether an imported module is a sibling capability
  * or a nested child needs the module graph, and a rule reading one file at a time cannot see it. In
  * the reference repository that rule exists and is scoped by path glob; a repository adopting this
- * law should port it as a gate that walks the tree, not as a per-file rule that guesses.
+ * law should port it as a gate that walks the tree, not as a per-file rule that guesses. The same
+ * reasoning is why `no-self-global-module` stops at the `@Global()` decorator and does not also
+ * chase a hardcoded `isGlobal: true` passed into a `.register(...)` call -- this repository passes
+ * that option through at every level of legitimate nesting, and only the module graph can tell a
+ * nested child from a foreign capability.
  *
- * THE META-ROOT IS THE TRAP IN BOTH RULES. Some capabilities sit behind a category folder
+ * THE META-ROOT IS THE TRAP IN MOST OF THESE. Some capabilities sit behind a category folder
  * (`platform/`, `lib/`, `integrations/`), so the capability name is the SECOND segment there and
  * the first everywhere else. Get that wrong and `@modules/platform/exceptions` reads as a
  * capability-with-file rather than as a barrel.
@@ -152,20 +164,269 @@ export const noSelfModuleAlias = {
   },
 }
 
+// -- shared path arithmetic --------------------------------------------------------------------
+//
+// No fs anywhere below: every check in this file, old and new, reads a specifier string against a
+// filename string. Resolving a relative specifier therefore has to be done the same way -- pure
+// segment arithmetic against the importer's own path, never a disk lookup.
+
+/** POSIX-style dirname of an already-normalized (forward-slash) path. */
+const dirnameOf = (file) => {
+  const at = file.lastIndexOf("/")
+  return at === -1 ? "" : file.slice(0, at)
+}
+
+/**
+ * Resolves a relative specifier against the file that imports it, without touching disk.
+ *
+ * `..` pops a segment, `.` is a no-op, everything else pushes. Whether the importer's directory
+ * was rooted (a leading `/`) is preserved, so a POSIX-style absolute path stays POSIX-style after
+ * resolution; a Windows drive-letter path (`D:/repo/...`) already carries its root as its first
+ * segment and needs nothing extra.
+ */
+const resolveRelativeSpecifier = (filename, specifier) => {
+  const dir = dirnameOf(normalizePath(filename))
+  const rooted = dir.startsWith("/")
+  const stack = dir.split("/").filter(Boolean)
+  for (const part of specifier.split("/")) {
+    if (part === "" || part === ".") continue
+    if (part === "..") {
+      stack.pop()
+      continue
+    }
+    stack.push(part)
+  }
+  return (rooted ? "/" : "") + stack.join("/")
+}
+
+// -- LAYERING-5 / Law 7 -------------------------------------------------------------------------
+
+/** This repository's own convention, and the law's Anchor: an `index.*` file at any depth. */
+const INDEX_FILE_RE = /(^|\/)index\.(ts|tsx|js|jsx|mjs|cjs)$/
+
+/** A specifier so bare it can only ever name a directory: `.`, `./`, `..`, `../`, or trailing `/`. */
+const isBareFolderSpecifier = (specifier) =>
+  specifier === "." || specifier === "./" || specifier === ".." || specifier === "../" || specifier.endsWith("/")
+
+/**
+ * LAYERING-5 / module-layering.md Law 7: no file re-exports a folder.
+ *
+ * Two certain signs, neither needing a disk lookup:
+ *  - a bare-dot or trailing-slash specifier names a directory by construction -- no file path ever
+ *    looks like that, aliased or relative, so there is nothing to guess;
+ *  - a file literally named `index.*` whose entire top-level body is re-export statements is the
+ *    exact shape the law's own Anchor measures ("Zero index.ts files in the entire source tree").
+ *
+ * What this deliberately does NOT flag: a single bridging re-export naming a real file
+ * (`export { AiInvokeService } from '@modules/ai/ai-invoke.service'`), which LAYERING-1's own
+ * common-business-situations list keeps legitimate, and a relative barrel that names a real
+ * multi-segment path with no file extension (`export * from './services'`) -- telling that apart
+ * from a real file with an implicit extension needs the filesystem, which no rule in this canon
+ * touches; see the module doc comment for why that gap is left to LAYERING-1's alias-only reach
+ * plus this filename check rather than guessed at.
+ */
+export const noFolderReexport = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "LAYERING-5 / module-layering.md Law 7: no file re-exports a folder -- a bare-directory specifier or an index barrel turns a capability's surface into a list nobody reads.",
+    },
+    schema: [],
+    messages: {
+      bareSpecifier:
+        "`{{specifier}}` names a directory, not a file. LAYERING-5: a capability's public surface is the files call sites actually import -- re-exporting a whole folder makes that surface a list nobody reads instead. Export the specific file.",
+      indexBarrel:
+        "This file is named `{{name}}` and its entire content is re-export statements -- the exact shape of an index barrel. LAYERING-5: this repository keeps zero `index.*` files so a barrel specifier never has anything to resolve to. Delete it and have callers import the real files directly.",
+    },
+  },
+  create(context) {
+    const filename = normalizePath(context.filename || context.getFilename())
+
+    const checkSpecifier = (node, specifier) => {
+      if (typeof specifier !== "string") return
+      if (isBareFolderSpecifier(specifier)) {
+        context.report({ node, messageId: "bareSpecifier", data: { specifier } })
+      }
+    }
+
+    return {
+      ImportDeclaration(node) {
+        checkSpecifier(node.source, node.source.value)
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) checkSpecifier(node.source, node.source.value)
+      },
+      ExportAllDeclaration(node) {
+        if (node.source) checkSpecifier(node.source, node.source.value)
+      },
+      "Program:exit"(node) {
+        if (!INDEX_FILE_RE.test(filename)) return
+        const body = node.body
+        const reexports = body.filter(
+          (stmt) =>
+            (stmt.type === "ExportNamedDeclaration" && stmt.source) || stmt.type === "ExportAllDeclaration",
+        )
+        if (reexports.length === 0 || reexports.length !== body.length) return
+        context.report({
+          node,
+          messageId: "indexBarrel",
+          data: { name: filename.slice(filename.lastIndexOf("/") + 1) },
+        })
+      },
+    }
+  },
+}
+
+// -- LAYERING-4 / Law 6 (partial) ----------------------------------------------------------------
+
+/** Files that build their own throwaway test graph rather than wiring a production capability. */
+const TEST_FILE_RE = /\.(spec|test)\.(ts|tsx|js|jsx|mjs|cjs)$/
+
+/**
+ * LAYERING-4 / module-layering.md Law 6, the one slice of it decidable without whole-application
+ * knowledge: a capability declaring `@Global()` on itself.
+ *
+ * The rest of Law 6 -- which capabilities exist at all, and what starts before what -- has no rule
+ * here, and the omission is deliberate, not an oversight. Both need knowledge a single file does
+ * not have: "which capabilities exist" is a fact about the whole application graph, and "what
+ * starts first" is recorded today as an English comment (`apps/core/src/main.ts`'s side-effect
+ * import), which a rule can only pattern-match on wording and would be guessing at meaning, not
+ * reading syntax.
+ *
+ * `isGlobal` passed as a plain, caller-supplied OPTION (`.register({ isGlobal: false })`,
+ * `.setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal
+ * }))`) is deliberately OUT of scope too, and measuring the reference repository is why: it passes
+ * that literal option at every level of nesting, including a capability's own top module wiring its
+ * own nested children (`CoreModule.register({ isGlobal: true })` inside `features/api/api.module.ts`,
+ * which is nesting, not the sideways declaration Law 6 refuses). Telling "a nested child" from "a
+ * foreign capability" needs the module graph -- the exact reason LAYERING-3 stays a documented code
+ * rather than an enforced one, and the same reason applies here. `@Global()` carries none of that
+ * ambiguity: it declares the module global unconditionally, for every caller, which is precisely
+ * the fact Law 6 says only a composition root gets to state.
+ */
+export const noSelfGlobalModule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "LAYERING-4 / module-layering.md Law 6: which capabilities are global is stated only at the composition root -- a capability's own file may not declare itself `@Global()`.",
+    },
+    schema: [],
+    messages: {
+      global:
+        "`@Global()` declares this module global from inside its own capability. LAYERING-4: whether a capability is global is a fact about the APPLICATION, decided per-application at the composition root (`AiModule.register({ isGlobal: true })` in `apps/*/src/app.module.ts`), not a fact a capability gets to state about itself. Remove the decorator and pass `isGlobal` through as a caller-supplied option instead.",
+    },
+  },
+  create(context) {
+    const filename = normalizePath(context.filename || context.getFilename())
+    if (TEST_FILE_RE.test(filename)) return {}
+    const self = selfAliases(filename)
+    if (!self || self.prefix === "@tests/") return {}
+
+    return {
+      Decorator(node) {
+        const expr = node.expression
+        const name =
+          expr.type === "CallExpression"
+            ? expr.callee.type === "Identifier"
+              ? expr.callee.name
+              : null
+            : expr.type === "Identifier"
+              ? expr.name
+              : null
+        if (name === "Global") {
+          context.report({ node, messageId: "global" })
+        }
+      },
+    }
+  },
+}
+
+// -- Law 8 ("moved to another repository") -------------------------------------------------------
+
+/**
+ * Law 8 / the law's own moved-capability test, read as a rule: a relative specifier may never leave
+ * the capability it is written in. `LAYERING-2` already says the path must be relative INSIDE a
+ * capability; this is the fact `LAYERING-2` does not check -- that a relative path can just as
+ * easily walk OUT (`../../other-capability/thing`), reaching a sibling capability without ever
+ * naming it through the declared public alias `LAYERING-1` requires. A file doing that could not be
+ * moved to another repository with its capability and still resolve: the relative path assumes the
+ * sibling is sitting right there on disk.
+ *
+ * Certain because it never touches disk either -- both sides of the comparison (the importer's own
+ * path, and the specifier resolved against it) run through the exact same `selfAliases` lookup this
+ * file already uses for `LAYERING-2`, so "different capability" is read off two path strings, not
+ * guessed from specifier text.
+ */
+export const noRelativeCapabilityEscape = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Law 8 (module-layering.md): a capability moved to another repository still resolves every import it declares -- a relative specifier may not walk out of its own capability.",
+    },
+    schema: [],
+    messages: {
+      escape:
+        "`{{specifier}}` is a relative import that leaves the `{{from}}` capability and reaches `{{to}}`. Law 8: this capability could not be moved to another repository and still resolve that path -- cross a capability boundary through its declared public alias (LAYERING-1), never by walking out with `../`.",
+    },
+  },
+  create(context) {
+    const filename = normalizePath(context.filename || context.getFilename())
+    const self = selfAliases(filename)
+    if (!self) return {}
+
+    const check = (node, specifier) => {
+      if (typeof specifier !== "string") return
+      if (!specifier.startsWith("./") && !specifier.startsWith("../")) return
+      const resolved = resolveRelativeSpecifier(filename, specifier)
+      const target = selfAliases(resolved)
+      if (!target) return
+      if (target.prefix === self.prefix && target.keys[0] === self.keys[0]) return
+      context.report({
+        node,
+        messageId: "escape",
+        data: { specifier, from: self.keys[0], to: target.keys[0] },
+      })
+    }
+    return {
+      ImportDeclaration(node) {
+        check(node.source, node.source.value)
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) check(node.source, node.source.value)
+      },
+      ExportAllDeclaration(node) {
+        if (node.source) check(node.source, node.source.value)
+      },
+    }
+  },
+}
+
 /** The rules this law contributes to the plugin. */
 export const rules = {
   "must-deep-module-import": mustDeepModuleImport,
   "no-self-module-alias": noSelfModuleAlias,
+  "no-folder-reexport": noFolderReexport,
+  "no-self-global-module": noSelfGlobalModule,
+  "no-relative-capability-escape": noRelativeCapabilityEscape,
 }
 
 /**
  * The level this law asks for, as the plugin's own opinion.
  *
- * Both measured at zero debt in the reference repository. A repository adopting them into an
- * existing tree will not be at zero: barrels are the default in most codebases, so measure first
- * and land above zero at `warn` with the count, exactly as the burn-down procedure says.
+ * All five measured at zero debt in the reference repository -- the three added alongside
+ * `no-folder-reexport`, `no-self-global-module` and `no-relative-capability-escape` fired zero
+ * times across the repository's ~4700 `src/**` TypeScript files, verified against a harness that
+ * DOES fire on synthetic violations of each (so the zero is measured, not a broken rule going
+ * quiet). A repository adopting any of these five into an existing tree will not be at zero: land
+ * above zero at `warn` with the count, exactly as the burn-down procedure says.
  */
 export const recommended = {
   "starci-be/must-deep-module-import": "error",
   "starci-be/no-self-module-alias": "error",
+  "starci-be/no-folder-reexport": "error",
+  "starci-be/no-self-global-module": "error",
+  "starci-be/no-relative-capability-escape": "error",
 }

package/naming.mjs

@@ -1,10 +1,11 @@
 /**
  * The rules that hold `naming.md`.
  *
- * Two rules, which are the only two parts of naming a parser can actually judge: whether a name
- * encodes a schema VERSION, and whether an exported function is a bare verb.
+ * Three rules, which are the parts of naming a parser can actually judge: whether a name encodes a
+ * schema VERSION, whether an exported function is a bare verb, and whether a `.module.ts` file's
+ * OWN static factory borrows a vendor dynamic-module's exact name instead of this tree's `register`.
  *
- * A THIRD RULE WAS WRITTEN AND DELETED, and the deletion is the useful part. It demanded that a
+ * A FOURTH RULE WAS WRITTEN AND DELETED, and the deletion is the useful part. It demanded that a
  * file name spell out the class it declares, and measured 616 offenders in 4430 files -- because
  * the convention is the opposite of what it assumed: the PATH carries the role and the scope
  * (`parsers/content.service.ts` and `path/content.service.ts` declare `ContentParserService` and
@@ -12,6 +13,14 @@
  * convention, not debt. Canon records what the code does; a rule that disagrees with the code at
  * that scale is the rule being wrong.
  *
+ * The module-factory rule (NAME-1) stays narrow on purpose: it visits DECLARATIONS only -- a static
+ * method on a class this repository declares, decorated `@Module(...)` -- and never a CallExpression,
+ * so `BullModule.forRoot(...)`, `ConfigModule.forRoot(...)`, `TypeOrmModule.forFeature(...)` and
+ * `SentryCoreModule.forRoot(...)` are calls into vendor code and are never reported. Its forbidden
+ * set is closed to the four literal vendor names (`forRoot`, `forRootAsync`, `forFeature`,
+ * `forFeatureAsync`); a repository-invented auxiliary factory like `registerQueue` does not collide
+ * with a vendor shape and is left alone.
+ *
  * The rest of the law is not enforced and should not be faked. Whether a name describes a folder
  * (NAME-3), a mechanism (NAME-4) or its first caller (NAME-7) needs to know what the thing IS --
  * `VolumeService` reads perfectly well until you know the folder was renamed, and no parser knows
@@ -46,6 +55,72 @@ const BARE_VERBS = new Set([
   "apply",
 ])
 
+// -- NAME-1 ----------------------------------------------------------------------------------------
+
+/** Decorator names carried by a class declaration. */
+const decoratorNames = (node) =>
+  (node.decorators || []).map((decorator) => {
+    const expression = decorator.expression
+    if (expression.type === "CallExpression" && expression.callee.type === "Identifier") return expression.callee.name
+    if (expression.type === "Identifier") return expression.name
+    return null
+  }).filter(Boolean)
+
+/**
+ * Vendor dynamic-module factory names, each mapped to the house name a `.module.ts` file's own
+ * factory declares instead: `register`, or `registerAsync` for its async companion.
+ *
+ * This is a CLOSED list of the exact method names Nest's own modules publish
+ * (`ConfigModule.forRoot`, `TypeOrmModule.forFeature`, `BullModule.forRootAsync`,
+ * `SentryCoreModule.forRoot`). A repository class that declares its OWN static factory under one of
+ * these names is not calling the vendor - it is shaped like the vendor, which is exactly what makes
+ * `PrimaryPostgreSQLModule.forFeature()` unreadable at a glance from `TypeOrmModule.forFeature()`:
+ * same literal name, two different owners, and nothing at the call site says which.
+ */
+const VENDOR_FACTORY_NAMES = new Map([
+  ["forRoot", "register"],
+  ["forRootAsync", "registerAsync"],
+  ["forFeature", "register"],
+  ["forFeatureAsync", "registerAsync"],
+])
+
+/** A `.module.ts` file's own static factory is named `register`, never a vendor's factory shape. */
+export const noVendorModuleFactoryName = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "NAME-1: a `.module.ts` file's own static factory is named `register` (`registerAsync` for its async companion), never a vendor dynamic-module name it does not own.",
+    },
+    schema: [],
+    messages: {
+      vendorShaped:
+        "`{{name}}` is a module declared IN THIS REPOSITORY, but its static factory is named `{{method}}` - the exact name Nest's own vendor modules publish (`ConfigModule.forRoot`, `TypeOrmModule.forFeature`, `BullModule.forRootAsync`). A reader hitting `{{name}}.{{method}}(...)` in an `imports:` list cannot tell, from the name alone, whether that call lands in this class or forwards straight into a vendor's. Thirty-nine other modules in this tree already answer that question by calling this factory `{{suggestion}}` instead - a name no vendor already owns. Rename `{{method}}` to `{{suggestion}}`.",
+    },
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        if (!node.static) return
+        if (!node.key || node.key.type !== "Identifier") return
+        const suggestion = VENDOR_FACTORY_NAMES.get(node.key.name)
+        if (!suggestion) return
+
+        const classBody = node.parent
+        const classNode = classBody && classBody.parent
+        if (!classNode || !decoratorNames(classNode).includes("Module")) return
+
+        const name = (classNode.id && classNode.id.name) || "this module"
+        context.report({
+          node: node.key,
+          messageId: "vendorShaped",
+          data: { name, method: node.key.name, suggestion },
+        })
+      },
+    }
+  },
+}
+
 // -- NAME-2 ----------------------------------------------------------------------------------------
 
 /** A name says what a thing is, never which schema generation it was built for. */
@@ -126,6 +201,7 @@ export const noBareVerbExport = {
 export const rules = {
   "no-version-in-name": noVersionInName,
   "no-bare-verb-export": noBareVerbExport,
+  "no-vendor-module-factory-name": noVendorModuleFactoryName,
 }
 
 /**
@@ -140,4 +216,5 @@ export const rules = {
 export const recommended = {
   "starci-be/no-version-in-name": "warn",
   "starci-be/no-bare-verb-export": "warn",
+  "starci-be/no-vendor-module-factory-name": "warn",
 }

package/observability.mjs

@@ -102,21 +102,154 @@ export const noInterpolatedLogMessage = {
   },
 }
 
+// -- OBSERVABILITY-5 -------------------------------------------------------------------------------
+
+/** Whether `node` is a bare reference to the caught error, by name. */
+const isIdentifierNamed = (node, name) => Boolean(node) && node.type === "Identifier" && node.name === name
+
+/** How each wording shape reads back to the author, keyed by the `kind` pushed in `scanErrorUsage`. */
+const WORDING_SHAPES = {
+  message: (name) => `\`${name}.message\``,
+  stringWrap: (name) => `\`String(${name})\``,
+  template: (name) => `a template literal that interpolates \`${name}\` directly`,
+}
+
+/**
+ * Walk a log call's data arguments for two things beside the caught error: a reference that carries
+ * only its rendered WORDING (`.message`, `String(error)`, `${error}` inside a template), and a
+ * reference that carries its IDENTITY (`.code`). The walk is a shallow recursion over the expression
+ * shapes a data object is normally built from - object properties, array elements, template
+ * expressions, ternary branches, boolean joins. It does not need a type checker: these three wording
+ * shapes and the one identity shape are syntactic, not semantic, which is exactly the boundary
+ * OBSERVABILITY-5 draws between what a parser can hold and what needs a reader.
+ */
+const scanErrorUsage = (node, errorName, found) => {
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return
+  switch (node.type) {
+    case "MemberExpression":
+      if (!node.computed && isIdentifierNamed(node.object, errorName) && node.property.type === "Identifier") {
+        if (node.property.name === "message") found.wording.push({ node, kind: "message" })
+        if (node.property.name === "code") found.identity.push(node)
+      }
+      scanErrorUsage(node.object, errorName, found)
+      break
+    case "CallExpression":
+      if (
+        node.callee.type === "Identifier" && node.callee.name === "String"
+        && node.arguments.length === 1 && isIdentifierNamed(node.arguments[0], errorName)
+      ) {
+        found.wording.push({ node, kind: "stringWrap" })
+      }
+      for (const arg of node.arguments) scanErrorUsage(arg, errorName, found)
+      break
+    case "TemplateLiteral":
+      for (const expr of node.expressions) {
+        if (isIdentifierNamed(expr, errorName)) found.wording.push({ node: expr, kind: "template" })
+        else scanErrorUsage(expr, errorName, found)
+      }
+      break
+    case "ObjectExpression":
+      for (const prop of node.properties) scanErrorUsage(prop, errorName, found)
+      break
+    case "Property":
+      scanErrorUsage(node.value, errorName, found)
+      break
+    case "ArrayExpression":
+      for (const el of node.elements) scanErrorUsage(el, errorName, found)
+      break
+    case "ConditionalExpression":
+      scanErrorUsage(node.consequent, errorName, found)
+      scanErrorUsage(node.alternate, errorName, found)
+      break
+    case "LogicalExpression":
+    case "BinaryExpression":
+      scanErrorUsage(node.left, errorName, found)
+      scanErrorUsage(node.right, errorName, found)
+      break
+    default:
+      break
+  }
+}
+
+/**
+ * A failure log's data carries the exception's `code`, not only its rendered message. Scoped to log
+ * calls sitting inside a `catch`, and to references to that `catch`'s OWN error identifier - a field
+ * that happens to be named `error` elsewhere is not this rule's business, and neither is a call
+ * outside a `catch`, since OBSERVABILITY-5 only binds where the line is what an alert groups by.
+ */
+export const noErrorWordingAsLogIdentity = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "OBSERVABILITY-5 (Rule 5): a failure log's data carries the exception's `code`, so improving the wording never splits an alert in two.",
+    },
+    schema: [],
+    messages: {
+      wordingOnly:
+        "This failure log carries {{shape}} but never `{{errorName}}.code`. Wording is what a person reads; code is what a dashboard groups by. Fuse the two and the alert lives or dies on how the sentence happens to be phrased today - reword it tomorrow for clarity and the old alert goes silent while a new one opens under the reworded text. Add `{{errorName}}.code` (and any other identity metadata) to the data, and keep the message only as a secondary field beside it.",
+    },
+  },
+  create(context) {
+    const catchStack = []
+    return {
+      CatchClause(node) {
+        catchStack.push(node.param && node.param.type === "Identifier" ? node.param.name : null)
+      },
+      "CatchClause:exit"() {
+        catchStack.pop()
+      },
+      CallExpression(node) {
+        const errorName = catchStack[catchStack.length - 1]
+        if (!errorName) return
+        const callee = node.callee
+        if (callee.type !== "MemberExpression" || callee.computed) return
+        const method = callee.property.name
+        if (!LOG_METHODS.has(method)) return
+        if (!isLoggerReceiver(callee.object)) return
+
+        // the event name (first argument) is OBSERVABILITY-2's business, not this rule's
+        const dataArgs = node.arguments.slice(1)
+        if (dataArgs.length === 0) return
+
+        const found = { wording: [], identity: [] }
+        for (const arg of dataArgs) scanErrorUsage(arg, errorName, found)
+        if (found.wording.length > 0 && found.identity.length === 0) {
+          const first = found.wording[0]
+          context.report({
+            node: first.node,
+            messageId: "wordingOnly",
+            data: { errorName, shape: WORDING_SHAPES[first.kind](errorName) },
+          })
+        }
+      },
+    }
+  },
+}
+
 /** The rules this law contributes to the plugin. */
 export const rules = {
   "no-framework-logger": noFrameworkLogger,
   "no-interpolated-log-message": noInterpolatedLogMessage,
+  "no-error-wording-as-log-identity": noErrorWordingAsLogIdentity,
 }
 
 /**
  * The level this law asks for, as the plugin's own opinion.
  *
- * Both measured at zero debt in the reference repository ONCE the sanctioned exit is scoped:
- * `no-framework-logger` reports four sites under the standalone-agent folder, and those are the
- * exit rather than the debt. An agent running outside the request lifecycle has no request to
- * correlate and no transport configured, so the house service would give it a dependency and
- * nothing else. Scope that folder off in the consuming config -- once, by path -- rather than
- * letting per-line suppressions accumulate until nobody can see how wide the exception has grown.
+ * `no-framework-logger` and `no-interpolated-log-message` are both measured at zero debt in the
+ * reference repository ONCE the sanctioned exit is scoped: `no-framework-logger` reports four sites
+ * under the standalone-agent folder, and those are the exit rather than the debt. An agent running
+ * outside the request lifecycle has no request to correlate and no transport configured, so the
+ * house service would give it a dependency and nothing else. Scope that folder off in the consuming
+ * config -- once, by path -- rather than letting per-line suppressions accumulate until nobody can
+ * see how wide the exception has grown.
+ *
+ * `no-error-wording-as-log-identity` measures at 64 offenders across 39 files in the reference
+ * repository (`src/**`, probed against source directly since the published package predates this
+ * rule) -- real debt, not zero, so it ships at `warn` with that count on record rather than `error`.
+ * Flip to `error` once the count reaches zero; shipping `error` over standing debt is what teaches an
+ * author to scroll past a rule instead of fixing it.
  *
  * `no-console` is the standard rule rather than a house one, listed here so a repository switches
  * all three on together: it is the third way out of the pipeline, and leaving it off makes the
@@ -125,6 +258,7 @@ export const rules = {
 export const recommended = {
   "starci-be/no-framework-logger": "error",
   "starci-be/no-interpolated-log-message": "error",
+  "starci-be/no-error-wording-as-log-identity": "warn",
   "no-console": "error",
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-be",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "The StarCi back-end lint canon: every rule its laws publish, gathered as one flat-config plugin.",
   "type": "module",
   "license": "UNLICENSED",