rcf-lite 0.32.1 → 0.32.3

package/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.32.3] - 2026-10-07
+
+0.32.3 is a hotfix for the 0.32.2 D6 consistency:unsatisfiable regression discovered by Barry on ai-on-record (define/kickoff, head 974b4c1) and second-sourced by Dex on WESPA (26 green-to-red findings in three classes, 2026-10-06 20:05Z). The regression came from pattern 4 of `extractThenFieldTokens` in `src/query/gates.js`, added in PR 313 as part of the issue 311 fix. breaking: false; the 0.32.1 and 0.32.2 fixes carry forward unchanged. minAgentAction: null.
+
+### Fixed
+
+- **D6 consistency:unsatisfiable stops reading filename stems, non-shape PascalCase dot phrases and sentence-ending dots as record-field references (issue 315, w-2026-10-06-dave-059).** 0.32.2 added a pattern 4 to `extractThenFieldTokens` that fired `consistency:unsatisfiable` on any `<PascalCase>.<lowercaseWord>` match in an AC `then` clause. On ai-on-record define/kickoff that read `CLAUDE.md`, `AGENTS.md`, `rcf/evals/corpus-V.json`, `rcf/evals/golden-transcripts-V.json` and other filename stems as record fields and false-failed AC-1501-9:md, AC-2201-1:json, AC-2201-5:json and AC-2201-8:json. Dex's WESPA re-run on 2026-10-06 20:05Z (AI-1987) added 26 findings in three classes: filename stems with a filename-stem head (js x7, vue x5, md x1), PascalCase heads that are not recordShape names in the tree (`Math.random`, `TEST_USERS.admin`, `ToolExecutionContext.pushLlmCall`, `LoadedFilterSchema.distinctLiveSourceTables`, and backticked dot-phrases like `` `Something.listModelInfo` ``, `` `Something.userID` ``), and AC-130-1 producing the token `the` from a sentence-ending dot inside a dot-separated phrase (`Foo.the`). Fix: pattern 4 is now gated on the head to the left of the dot resolving to a recordShape name declared somewhere in the tree. `collectRecordShapeNames` walks the TAC interfaces alongside the existing `collectRecordShapeFields` and the resulting shape-name set is threaded through `extractThenFieldTokens` as a second argument. Three belt-and-braces guards stay in behind the shape-name gate so a hostile shape-name collision cannot reintroduce the class: an English-stop-word skip on the field token (so `Foo.the` is silent even if a shape named `Foo` were declared), a closed file-extension skip (md, json, jsonl, html, css, js, mjs, cjs, ts, vue, yaml, yml, txt, csv, pdf, png, jpg, svg, zip, wav, mp4, mov, log) and a two-char lookbehind path-context skip (preceded by `/` or `./`). Patterns 1 (narrowed backticked identifier), 2 (`<name> field`), 3 (`field: <name>`), the issue 311 fixtures and the AC-12113-2 class are preserved. Regression fixtures in `test/query/gates.test.js` cover each of the three new classes plus a positive control (`Session.lastSeenAt` where Session is declared without `lastSeenAt`) and a verbatim quote of the four ai-on-record ACs at head 974b4c1 as negative controls. Expected drop on WESPA: 26 unsatisfiable findings removed; the issue 311 drop and all AC-12113-2 class failures remain.
+
+## [0.32.2] - 2026-10-06
+
+0.32.2 ships two Dex-lane fixes merged since 0.32.1 (merge b478a4e) as the WESPA readiness alignment release. D6 consistency:unsatisfiable now context-gates backticked identifiers in AC then-clauses so enum values, query-string parameter names, sort and filter literals, env-var names and config knobs stop being read as record-shape field names, and `rcf discover req-baseline opt-out` and `rcf define ledger concerns add` honour `--dry-run` by writing nothing. breaking: false; no behavioural changes on verbs consumers run in CI; fixes only. minAgentAction: null; the managed agent-instructions block hash did not move.
+
+### Fixed
+
+- **D6 consistency:unsatisfiable stops reading backticked enum values, query-string parameter names, sort and filter literals, env-var and config-knob names as record-shape field names (issue 311, w-2026-10-06-dave-050).** `extractThenFieldTokens` in `src/query/gates.js` previously fired `consistency:unsatisfiable` on any backticked identifier in an AC `then` clause and treated every token it caught as a field some `recordShape` had to define. On WESPA (rcf-lite 0.31.0, main `df0fa47e`) 345 of 532 flagged tokens were not fields: HTTP error-envelope `code` enum values like `VALIDATION_ERROR` and `AUTH_TOKEN_INVALID_SIGNATURE`, pagination query-string keys like `pageSize`, `offset`, `cursors` and sort-order values like `asc`, `desc`, `next`, filter and match-mode literals like `query`, `exact`, `in`, env-var names like `BUILD_GIT_COMMIT_SHORT` and config knobs like `maxDiffPixelRatio`, `fullPath`, `workerAdminUser`. Fix: pattern 1 (bare backticked identifier) is now context-gated. ALL_CAPS tokens (enum values, env vars, constants) are skipped unconditionally. Other backticked tokens count only when a field-signalling word (a verb like `set`, `write`, `include`, `return`, `contain`; a predicate like `is set`, `is written`, `equals`, `holds`; or a context word like `field`, `record shape`, `response body`, `request body`, `payload`, `envelope`) sits within a short neighbourhood AND no explicit non-field context (`query parameter`, `query-string`, `sort order`, `sort direction`, `filter mode`, `match mode`, `enum value`, `env var`, `environment variable`, `config knob`, `config key`, `header name`, `cli flag`) overlaps the same neighbourhood. Pattern 4 added: `<ShapeName>.<fieldName>` dot notation is now read as a schema-style field reference. Patterns 2 (`<name> field`) and 3 (`field: <name>`) are preserved and the AC-12113-2 class is unchanged: a then-clause that names a real undefined field still fails. Regression fixtures in `test/query/gates.test.js` cover each of the five WESPA token patterns from the issue plus a dot-notation negative control and a plain-prose negative control. Expected drop on WESPA: 345 unsatisfiable findings removed; the 187 true-positive findings and all AC-12113-2 class failures remain.
+
+- **`--dry-run` on `rcf discover req-baseline opt-out` and `rcf define ledger concerns add` writes nothing (issue 310, w-2026-10-06-dave-050).** Both verbs accepted the flag but wrote the opt-out record to `rcf/manifest.json` (`baselineAcOptOuts[]`) and created `rcf/define/concern-ledger.json` with the appended entry respectively, mutating viewer clones on rehearsal runs. Fix: `src/cli/req-baseline.js` opt-out verb and `src/cli/ledger.js` concerns handler both check `flags['dry-run']` before the write and emit a `[dry-run]` preview line (or a `{dryRun: true, ...}` JSON payload with `--json`) and exit 0. Help text updated on both verbs to document the flag. Regression tests in `test/cli/req-baseline-opt-out-dry-run.test.js` (new) and `test/cli/ledger.test.js` assert the on-disk bytes under `rcf/` are byte-equal before and after each dry-run and that the positive control (no `--dry-run`) still writes.
+
 ## [0.32.1] - 2026-10-06
 
 0.32.1 ships two fixes merged since 0.32.0 (merge b6292f5) on top of the layout baseline chore. The viewer's Readiness tab now agrees with the CLI on D3 shapes:pathsResolve, and the D5 crosscut:operationalConcerns trigger reads the structured ac.scope field in addition to the legacy "[deployed]" marker. breaking: false; no behavioural changes on verbs consumers run in CI; fixes only. minAgentAction: null; the managed agent-instructions block hash did not move.

package/fixtures/canary-manifest.json

@@ -1,9 +1,9 @@
 {
   "registerCanary": [
     {
-      "id": "rc-2026-10-06-001",
-      "createdAt": "2026-10-06T18:28:43.472Z",
-      "buildVersion": "0.32.1-mockdriver",
+      "id": "rc-2026-10-07-001",
+      "createdAt": "2026-10-07T10:44:10.684Z",
+      "buildVersion": "0.32.3-mockdriver",
       "fixturePromptId": "canary-prompt-01",
       "responseWordCount": 55,
       "grades": {
@@ -34,9 +34,9 @@
       "shipDespiteFailReason": "mock canary driver used; no real subagent was dispatched. This record verifies canary infrastructure only, not the register itself."
     },
     {
-      "id": "rc-2026-10-06-002",
-      "createdAt": "2026-10-06T18:28:43.473Z",
-      "buildVersion": "0.32.1-mockdriver",
+      "id": "rc-2026-10-07-002",
+      "createdAt": "2026-10-07T10:44:10.684Z",
+      "buildVersion": "0.32.3-mockdriver",
       "fixturePromptId": "canary-prompt-02",
       "responseWordCount": 55,
       "grades": {
@@ -67,9 +67,9 @@
       "shipDespiteFailReason": "mock canary driver used; no real subagent was dispatched. This record verifies canary infrastructure only, not the register itself."
     },
     {
-      "id": "rc-2026-10-06-003",
-      "createdAt": "2026-10-06T18:28:43.473Z",
-      "buildVersion": "0.32.1-mockdriver",
+      "id": "rc-2026-10-07-003",
+      "createdAt": "2026-10-07T10:44:10.684Z",
+      "buildVersion": "0.32.3-mockdriver",
       "fixturePromptId": "canary-prompt-03",
       "responseWordCount": 55,
       "grades": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rcf-lite",
-  "version": "0.32.1",
+  "version": "0.32.3",
   "type": "module",
   "description": "One-install tooling for the Requirements Confidence Framework (RCF): the unified `rcf` CLI grouped into the five RCF tool groups (discover, define, build, verify, audit) plus a small core set (init, doctor, guidance, mcp), an MCP server, the live tree viewer and the fresh-context adversarial ship-gate verifier. Consumes @stravica-ai/rcf-schemas.",
   "license": "Apache-2.0",

package/releases/releases.yaml

@@ -40,8 +40,24 @@
 # `npm install rcf-lite`.
 
 feedVersion: 1
-latest: "0.32.1"
+latest: "0.32.3"
 releases:
+  - version: "0.32.3"
+    date: "2026-10-07"
+    breaking: false
+    headlines:
+      - "rcf-lite 0.32.3 is a hotfix for the 0.32.2 D6 consistency:unsatisfiable regression on filename stems and non-shape dot phrases (issue 315). Pattern 4 of extractThenFieldTokens now emits a field token only when the head to the left of the dot is a declared recordShape name in the tree, so AC then-clauses that mention report.json, CLAUDE.md, scripts/seeds/README.md, Math.random, TEST_USERS.admin, ToolExecutionContext.pushLlmCall and sentence-ending dots like Foo.the stop reading as record-field references; file-extension, path-context and English-stop-word skips stay as belt and braces. The 0.32.1 and 0.32.2 fixes carry forward unchanged."
+    minAgentAction: null
+    notesUrl: "https://stravica.ai/docs/rcf/changelog/"
+
+  - version: "0.32.2"
+    date: "2026-10-06"
+    breaking: false
+    headlines:
+      - "rcf-lite 0.32.2 ships two Dex-lane fixes on top of 0.32.1. D6 consistency:unsatisfiable now context-gates backticked identifiers in AC then-clauses so enum values, query-string parameter names, sort and filter literals, env-var names and config knobs stop being read as record-shape field names (issue 311; expected drop on WESPA 345 unsatisfiable findings, 187 true positives remain, AC-12113-2 class unchanged), and `rcf discover req-baseline opt-out` and `rcf define ledger concerns add` honour `--dry-run` by writing nothing (issue 310)."
+    minAgentAction: null
+    notesUrl: "https://stravica.ai/docs/rcf/changelog/"
+
   - version: "0.32.1"
     date: "2026-10-06"
     breaking: false

package/src/cli/ledger.js

@@ -112,6 +112,7 @@ concerns add flags:
   --disposition applied|waived
                             Disposition (required)
   --reason <text>           Reason (mandatory when disposition=waived)
+  --dry-run                 Preview the minted entry; write nothing
 
 probes add flags:
   --req <req-id>            REQ the probe finding sits on (required)
@@ -523,6 +524,20 @@ async function runAdd({ projectRoot, name, flags, stdout, stderr }) {
       name: 'concerns', body, entry, now,
       ...(idOverride !== undefined ? { id: idOverride } : {}),
     });
+    // Issue 310 (0.32.2): --dry-run on concerns add previews the
+    // minted entry without writing the ledger. Prior behaviour
+    // accepted the flag and created `rcf/define/concern-ledger.json`
+    // anyway, mutating viewer clones on rehearsal runs.
+    if (flags['dry-run']) {
+      if (flags.json) {
+        stdout.write(`${JSON.stringify({ dryRun: true, status: step.status, id: step.entry.id, entry: step.entry }, null, 2)}\n`);
+      } else if (step.status === 'unchanged') {
+        stdout.write(`[dry-run] concern-ledger: would be unchanged ${step.entry.id}\n`);
+      } else {
+        stdout.write(`[dry-run] concern-ledger: would add concern ${step.entry.id}\n`);
+      }
+      return 0;
+    }
     if (step.status === 'unchanged') {
       if (flags.json) {
         stdout.write(`${JSON.stringify({ status: 'unchanged', id: step.entry.id, entry: step.entry }, null, 2)}\n`);

package/src/cli/req-baseline.js

@@ -60,12 +60,14 @@ Verbs:
                              (silence-refuses-build queue) without
                              prompting.
 
-  opt-out --req <id> --key <baselineKey> --reason "..." [--scope req|project]
+  opt-out --req <id> --key <baselineKey> --reason "..." [--scope req|project] [--dry-run]
                              Record an operator ruling that removes a
                              baseline AC from the REQ (or the whole
                              project) and inherit the ruling on future
                              sweeps. Reason is at least 20 characters
-                             (schema-enforced).
+                             (schema-enforced). --dry-run prints the
+                             opt-out that would be written and leaves
+                             the manifest untouched.
 
   opt-out --remove --req <id> --key <baselineKey>
                              Delete an existing opt-out; the next sweep
@@ -252,6 +254,18 @@ export async function main(argv, deps = {}) {
     stderr.write(`[error] usage req-baseline opt-out: --scope must be req or project (got ${scope})\n`);
     return 2;
   }
+  // Issue 310 (0.32.2): --dry-run on opt-out previews the opt-out
+  // record without writing to the manifest. Prior behaviour accepted
+  // the flag and wrote anyway, mutating viewer clones on rehearsal
+  // runs.
+  if (flags['dry-run']) {
+    if (flags.json) {
+      stdout.write(`${JSON.stringify({ dryRun: true, reqId: flags.req, baselineKey: flags.key, scope, reason: flags.reason }, null, 2)}\n`);
+    } else {
+      stdout.write(`[dry-run] would opt-out ${flags.req} ${flags.key} (scope=${scope})\n`);
+    }
+    return 0;
+  }
   const result = await writeOptOut({
     projectRoot,
     tree: walkResult.tree,

package/src/query/gates.js

@@ -1823,6 +1823,7 @@ export function checkD6Consistency(ctx) {
   // `[draft]` recordShape counts as defined (the engineer owns the
   // draft; its `fields:` list is honest about what the then may name).
   const definedFields = collectRecordShapeFields(tree);
+  const definedShapes = collectRecordShapeNames(tree);
   /** @type {Array<{ id: string, why: string }>} */
   const unsatisfiableFindings = [];
   let totalThenFieldChecks = 0;
@@ -1831,7 +1832,7 @@ export function checkD6Consistency(ctx) {
     for (const ac of acs) {
       const parts = parseWhenThen(ac?.description);
       if (!parts) continue;
-      const fields = extractThenFieldTokens(parts.then);
+      const fields = extractThenFieldTokens(parts.then, definedShapes);
       for (const field of fields) {
         totalThenFieldChecks += 1;
         if (definedFields.has(field)) continue;
@@ -2028,44 +2029,152 @@ function collectRecordShapeFields(tree) {
   return out;
 }
 
+/**
+ * Collect every recordShape interface name declared anywhere in the
+ * tree. Pattern 4 of `extractThenFieldTokens` (dot-notation
+ * `<Head>.<field>`) uses this set to gate: a Head that is not a
+ * declared shape name is not read as a record-field reference. This
+ * closes the 0.32.2 class in issue 315 where filename stems, non-shape
+ * PascalCase heads (Math.random, TEST_USERS.admin,
+ * ToolExecutionContext.pushLlmCall) and sentence-ending dots (Foo.the)
+ * were being read as record-field references.
+ *
+ * @param {import('#core/store/walker.js').TreeModel} tree
+ * @returns {Set<string>}
+ */
+function collectRecordShapeNames(tree) {
+  const out = new Set();
+  for (const tac of tree.tacs ?? []) {
+    for (const iface of tac.interfaces ?? []) {
+      if (iface?.kind !== 'recordShape') continue;
+      const name = iface?.name;
+      if (typeof name !== 'string' || name.length === 0) continue;
+      out.add(name);
+    }
+  }
+  return out;
+}
+
+// Closed list of file-extension tokens; pattern 4 (dot notation) never
+// emits a field token drawn from this set. Belt and braces behind the
+// shape-name gate: a tree with a recordShape literally named `Json` or
+// `Md` would still not read `foo.json`/`CLAUDE.md` as a field.
+const PATTERN_4_FILE_EXTENSION_SKIP = new Set([
+  'md', 'json', 'jsonl', 'html', 'css', 'js', 'mjs', 'cjs', 'ts', 'vue',
+  'yaml', 'yml', 'txt', 'csv', 'pdf', 'png', 'jpg', 'svg', 'zip', 'wav',
+  'mp4', 'mov', 'log',
+]);
+
 /**
  * Pull field tokens out of a `then` clause. A field token is a word
  * that follows a verb like `set`, `write`, `include`, `return`,
  * `contain`, `name` or appears as the direct object of a `then`'s
  * verb phrase; a cheap approximation uses `then <subject> <verb>
- * <field>` plus `field <name>`, `<name> field` and `field: <name>`
- * patterns. The scan is deliberately conservative so a plain English
- * sentence yields a small set.
+ * <field>` plus `field <name>`, `<name> field`, `field: <name>` and
+ * `<Shape>.<name>` patterns. The scan is deliberately conservative so
+ * a plain English sentence yields a small set.
+ *
+ * Issue 311 (0.32.2): a bare backticked identifier (pattern 1) was
+ * reading error-enum values, pagination query-string keys, sort and
+ * filter-mode literals, env-var and config-knob names as record-shape
+ * fields and false-positiving 345 of 532 ACs on WESPA. Pattern 1 is
+ * now context-gated: ALL_CAPS tokens (enum values, env vars,
+ * constants) are skipped unconditionally; other backticked tokens
+ * count only when a field-signalling word sits within a short
+ * neighbourhood AND no explicit non-field context (query parameter,
+ * sort order, filter/match mode, env var, config knob, header name,
+ * cli flag) overlaps the same neighbourhood. The AC-12113-2 class is
+ * preserved: a then-clause that names a real missing field via
+ * `<name> field`, `field: <name>` or an emit-verb context still fails
+ * the check.
  *
  * @param {string} thenClause
+ * @param {Set<string>} [shapeNames] - recordShape names declared in
+ *   the tree. Pattern 4 (`<Head>.<field>` dot notation) emits a field
+ *   token only when the head is a member of this set (issue 315).
  * @returns {string[]}
  */
-function extractThenFieldTokens(thenClause) {
+function extractThenFieldTokens(thenClause, shapeNames = new Set()) {
   if (typeof thenClause !== 'string' || thenClause.length === 0) return [];
   const text = stripQuotedSubstrings(thenClause);
   /** @type {Set<string>} */
   const tokens = new Set();
-  // Pattern 1: backticked identifier (`then `balance` is set`). The
-  // primary signal; prose that quotes a field name under backticks is
-  // the convention this check expects.
-  for (const m of text.matchAll(/`([A-Za-z_][A-Za-z0-9_]*)`/g)) {
-    if (m[1]) tokens.add(m[1]);
-  }
-  // Pattern 2: `<name> field` (adjective-form naming). An English
-  // "stop word" skip keeps "the field", "a field" and "its field" from
-  // tripping the check.
   const STOP = new Set(['the', 'a', 'an', 'this', 'that', 'its', 'our', 'their', 'any', 'no', 'some', 'each', 'every', 'another']);
-  for (const m of text.matchAll(/\b([A-Za-z_][A-Za-z0-9_]*)\s+field\b/g)) {
+
+  // Pattern 2 (preserved): `<name> field` (adjective-form naming). The
+  // backtick around the name is optional; the stop-word skip keeps
+  // "the field", "a field" and "its field" from tripping the check.
+  for (const m of text.matchAll(/`?\b([A-Za-z_][A-Za-z0-9_]*)`?\s+field\b/g)) {
     const token = m[1];
     if (!token) continue;
     if (STOP.has(token.toLowerCase())) continue;
     tokens.add(token);
   }
-  // Pattern 3: `field: <name>` or `field = <name>` (schema-like
-  // notation inside a then clause).
-  for (const m of text.matchAll(/\bfield\s*[:=]\s*([A-Za-z_][A-Za-z0-9_]*)/g)) {
+  // Pattern 3 (preserved): `field: <name>` or `field = <name>`
+  // (schema-like notation inside a then clause). The name's backtick
+  // is optional.
+  for (const m of text.matchAll(/\bfields?\s*[:=]\s*`?([A-Za-z_][A-Za-z0-9_]*)`?/g)) {
     if (m[1]) tokens.add(m[1]);
   }
+  // Pattern 4 (narrowed, issue 315): `<ShapeName>.<fieldName>` dot
+  // notation. Shape names are PascalCase. 0.32.2 emitted a field
+  // token whenever a PascalCase-ish head sat next to a lowercase dot
+  // tail, which read filename stems (`CLAUDE.md`, `*.json`,
+  // `report.json`), non-shape PascalCase heads (`Math.random`,
+  // `ToolExecutionContext.pushLlmCall`), bare-letter version tags
+  // (`corpus-V.json`) and sentence-ending dots inside a dotted
+  // phrase (`Foo.the`) as record fields. Narrowing: emit ONLY when
+  // the head resolves to a recordShape name declared somewhere in
+  // the tree. Three belt-and-braces guards remain regardless of the
+  // shape-name set so a hostile shape-name collision cannot
+  // reintroduce the class: the field is not an English stop word
+  // (sentence-dot), not a known file extension (filename stems),
+  // and the match does not sit inside a path context (preceded by
+  // `/` or `./`, which also catches backticked paths like
+  // `rcf/evals/corpus-V.json`).
+  for (const m of text.matchAll(/\b([A-Z][A-Za-z0-9_]*)\.([a-z_][A-Za-z0-9_]*)\b/g)) {
+    const head = m[1];
+    const field = m[2];
+    if (!head || !field) continue;
+    if (!shapeNames.has(head)) continue;
+    if (STOP.has(field.toLowerCase())) continue;
+    if (PATTERN_4_FILE_EXTENSION_SKIP.has(field.toLowerCase())) continue;
+    const start = m.index ?? 0;
+    const beforeHead = text.slice(Math.max(0, start - 2), start);
+    if (/[\/]/.test(beforeHead)) continue;
+    tokens.add(field);
+  }
+  // Pattern 1 (narrowed, issue 311): backticked identifier WITH
+  // explicit field evidence in its immediate neighbourhood AND no
+  // overlapping non-field context. ALL_CAPS tokens (enum values, env
+  // vars, constants) are skipped unconditionally; record-shape field
+  // names in the WSD AI tree and the rcf-schemas canon are camelCase
+  // or lower snake_case.
+  const WINDOW = 36;
+  const POS_BEFORE = /(?:\bsets?|\bsetting|\bwrites?|\bwriting|\bincludes?|\bincluding|\breturns?|\breturning|\bcontains?|\bcontaining|\bnames?|\bnaming|\bemits?|\bemitting|\bholds?|\bholding|\bcarries|\bcarrying|\badds?|\badding|\bhas|\bhave|\bhad|\bwith\s+(?:a|an|the))\s*$/i;
+  const POS_AFTER = /^\s*(?:\bis\s+(?:set|written|included|returned|named|populated|present|absent|missing|required|optional|null|non-null|empty)|\bare\s+(?:set|written|included|returned|named|populated|present|absent|missing|required|optional)|\bequals?|\bholds?|\bcontains?|\bof\s+type|\bfields?\b)/i;
+  const POS_CTX = /\bfields?\b|\brecord\s+shape\b|\brecord\s+body\b|\bresponse\s+body\b|\brequest\s+body\b|\bevent\s+body\b|\bpayload\b|\bevent\s+payload\b|\benvelope\b/i;
+  const NEG_CTX = /\bquery\s+param(?:eter)?s?\b|\bquery[- ]?string\b|\bsort\s+(?:order|direction|by|key)\b|\bfilter\s+mode\b|\bmatch\s+mode\b|\benum\s+(?:value|member|variant|literal)s?\b|\benv(?:ironment)?\s*var(?:iable)?s?\b|\benvironment\s+variable\b|\bconfig(?:uration)?\s+(?:knob|key|option|value|setting|field|file)\b|\bheader\s+(?:name|value|key)\b|\b(?:cli|flag|option|argument|parameter)\s+name\b|\bconstant\b|\badmin\s+user\b|\bbuild\s+(?:info|metadata)\b|\broute\b|\bendpoint\b|\boperator\b|\bdirection\b/i;
+
+  for (const m of text.matchAll(/`([A-Za-z_][A-Za-z0-9_]*)`/g)) {
+    const token = m[1];
+    if (!token) continue;
+    // Skip ALL_CAPS enum values, env vars, constants.
+    if (/^[A-Z][A-Z0-9_]*$/.test(token) && token.length >= 2) continue;
+    const start = m.index ?? 0;
+    const end = start + m[0].length;
+    const before = text.slice(Math.max(0, start - WINDOW), start);
+    const after = text.slice(end, Math.min(text.length, end + WINDOW));
+    if (NEG_CTX.test(before) || NEG_CTX.test(after)) continue;
+    if (
+      POS_BEFORE.test(before)
+      || POS_AFTER.test(after)
+      || POS_CTX.test(before)
+      || POS_CTX.test(after)
+    ) {
+      tokens.add(token);
+    }
+  }
   return [...tokens];
 }